lemon 0.8.1 → 0.8.2

data/lib/lemon/controller/test_runner.rb

@@ -0,0 +1,284 @@
+module Lemon
+
+  require 'lemon/model/main'
+  require 'lemon/model/test_suite'
+
+  # The TestRunner class handles the execution of Lemon tests.
+  class TestRunner
+
+    # Test suite to run.
+    attr :suite
+
+    #
+    attr :files
+
+    # Report format.
+    attr :format
+
+    # Record pass, fail, error, pending and omitted units.
+    attr :record
+
+    # New Runner.
+    def initialize(files, options={})
+      @files = files
+      @options = options
+
+      @record  = {:pass=>[], :fail=>[], :error=>[], :pending=>[], :omit=>[]}
+
+      ## TODO: can we create and assign the suite here?
+      @suite  = Lemon::TestSuite.new(files)  #([])
+      #@suite = Lemon.suite
+
+      initialize_rc  # TODO: before or after @suite = 
+
+      #files = files.map{ |f| Dir[f] }.flatten
+      #files = files.map{ |f| 
+      # if File.directory?(f)
+      #    Dir[File.join(f, '**/*.rb')]
+      #  else
+      #   f 
+      #  end
+      #}.flatten.uniq
+      #files = files.map{ |f| File.expand_path(f) }
+      #files.each{ |s| require s }
+    end
+
+    #
+    def initialize_rc
+      if file = Dir['./{.,}config/lemon/rc.rb'].first
+        require file
+      end
+    end
+
+    #
+    def format
+      @options[:format]
+    end
+
+    #
+    #def cover?
+    #  @options[:cover]
+    #end
+
+    # Namespaces option specifies the selection of test cases
+    # to run. Is is an array of strings which are matched 
+    # against the module/class names using #start_wtih?
+    def namespaces
+      @options[:namespaces] || []
+    end
+
+    # Run tests.
+    def run
+      #prepare
+      report.start_suite(suite)
+      each do |testcase|
+        scope = Object.new
+        scope.extend(testcase.dsl)
+        report.start_case(testcase)
+        if testcase.prepare #before[[]]
+          scope.instance_eval(&testcase.prepare)
+        end
+        testcase.each do |unit|
+          #case step
+          #when TestInstance
+          #  reporter.report_instance(step)
+          #when TestUnit
+          #  unit = step
+            if unit.omit?
+              report.omit(unit)
+              record[:omit] << unit
+              next
+            end
+            report.start_unit(unit)
+            run_pretest_procedures(unit, scope) #, suite, testcase)
+            begin
+              run_unit(unit, scope)
+              #unit.call(scope)
+              report.pass(unit)
+              record[:pass] << unit
+            rescue Pending => exception
+              exception = clean_backtrace(exception)
+              report.pending(unit, exception)
+              record[:pending] << [unit, exception]
+            rescue Assertion => exception
+              exception = clean_backtrace(exception)
+              report.fail(unit, exception)
+              record[:fail] << [unit, exception]
+            rescue Exception => exception
+              exception = clean_backtrace(exception)
+              report.error(unit, exception)
+              record[:error] << [unit, exception]
+            end
+            report.finish_unit(unit)
+            run_postest_procedures(unit, scope) #, suite, testcase)
+          #end
+        end
+        if testcase.cleanup #after[[]]
+          scope.instance_eval(&testcase.cleanup)
+        end
+        report.finish_case(testcase)
+      end
+      report.finish_suite(suite) #(successes, failures, errors, pendings)
+    end
+
+    # Iterate over suite testcases, filtering out unselected testcases
+    # if any namespaces are provided.
+    def each(&block)
+      if namespaces.empty?
+        suite.each do |testcase|
+          block.call(testcase)
+        end
+      else
+        suite.each do |testcase|
+          next unless namespaces.any?{ |n| testcase.target.name.start_with?(n) }
+          block.call(testcase)
+        end
+      end
+    end
+
+    # All output is handled by a reporter.
+    def report
+      @report ||= report_find(format)
+    end
+
+    # Find a report type be name fragment.
+    def report_find(format)
+      format = format ? format.to_s.downcase : 'dotprogress'
+      format = report_list.find do |r|
+        /^#{format}/ =~ r
+      end
+      raise "unsupported format" unless format
+      require "lemon/view/test_reports/#{format}"
+      reporter = Lemon::TestReports.const_get(format.capitalize)
+      reporter.new(self)
+    end
+
+    # Returns a list of report types.
+    def report_list
+      Dir[File.dirname(__FILE__) + '/../view/test_reports/*.rb'].map do |rb|
+        File.basename(rb).chomp('.rb')
+      end
+    end
+
+  private
+
+    #
+    def run_unit(unit, scope)
+      if unit.function? 
+        base = (class << unit.testcase.target; self; end)
+      else
+        base = unit.testcase.target
+      end
+
+      raise Pending unless unit.procedure
+
+      begin
+        base.class_eval do
+          alias_method "_lemon_#{unit.target}", unit.target
+          define_method(unit.target) do |*a,&b|
+            unit.tested = true
+            __send__("_lemon_#{unit.target}",*a,&b)
+          end
+        end
+      rescue => error
+        Kernel.eval %[raise #{error.class}, "#{unit.target} not tested"], unit.procedure
+      end
+      #Lemon.test_stack << self  # hack
+
+      begin
+        if unit.context && unit.procedure.arity != 0
+          cntx = unit.context.setup(scope)
+          scope.instance_exec(cntx, &unit.procedure) #procedure.call
+        else
+          scope.instance_exec(&unit.procedure) #procedure.call
+        end
+        unit.context.teardown(scope) if unit.context
+      ensure
+        #Lemon.test_stack.pop
+        base.class_eval %{
+          alias_method "#{unit.target}", "_lemon_#{unit.target}"
+        }
+      end
+      if !unit.tested
+        #exception = Untested.new("#{unit.target} not tested")
+        if RUBY_VERSION < '1.9'
+          Kernel.eval %[raise Pending, "#{unit.target} not tested"], unit.procedure
+        else
+          Kernel.eval %[raise Pending, "#{unit.target} not tested"], unit.procedure.binding
+        end
+      end
+    end
+
+=begin
+    #
+    def run_concern_procedures(concern, scope) #suite, testcase)
+      tc    = concern.testcase
+      suite = tc.suite
+      suite.when_clauses.each do |match, block|
+        if match.nil? or match === concern.to_s
+          #block.call #(test_case)
+          scope.instance_exec(tc, &block)
+        end
+      end
+      tc.when_clauses.each do |match, block|
+        if match.nil? or match === concern.to_s
+          if match === concern.to_s
+            #block.call #(test_case)
+            scope.instance_exec(tc, &block)
+          end
+        end
+      end
+      concern.call(scope)
+    end
+=end
+
+    # Run pre-test advice.
+    def run_pretest_procedures(unit, scope) #, suite, testcase)
+      suite = unit.testcase.suite
+      suite.before.each do |matches, block|
+        if matches.all?{ |match| unit.match?(match) }
+          scope.instance_exec(unit, &block) #block.call(unit)
+        end
+      end
+      unit.testcase.before.each do |matches, block|
+        if matches.all?{ |match| unit.match?(match) }
+          scope.instance_exec(unit, &block) #block.call(unit)
+        end
+      end
+    end
+
+    # Run post-test advice.
+    def run_postest_procedures(unit, scope) #, suite, testcase)
+      suite = unit.testcase.suite
+      unit.testcase.after.each do |matches, block|
+        if matches.all?{ |match| unit.match?(match) }
+          scope.instance_exec(unit, &block) #block.call(unit)
+        end
+      end
+      suite.after.each do |matches, block|
+        if matches.all?{ |match| unit.match?(match) }
+          scope.instance_exec(unit, &block) #block.call(unit)
+        end
+      end
+    end
+
+    EXCLUDE = Regexp.new(Regexp.escape(File.dirname(File.dirname(__FILE__))))
+
+    # Remove reference to lemon library from backtrace.
+    # TODO: Matching `bin/lemon` is not robust.
+    def clean_backtrace(exception)
+      trace = exception.backtrace
+      trace = trace.reject{ |t| t =~ /bin\/lemon/ }
+      trace = trace.reject{ |t| t =~ EXCLUDE }
+      if trace.empty?
+        exception
+      else
+        exception.set_backtrace(trace)
+        exception
+      end
+    end
+
+  end
+
+end
+

data/lib/lemon/meta/data.rb

@@ -0,0 +1,29 @@
+Object.__send__(:remove_const, :VERSION) if Object.const_defined?(:VERSION)      # becuase Ruby 1.8~ gets in the way
+
+module Lemon
+
+  def self.__DIR__
+    File.dirname(__FILE__)
+  end
+
+  def self.gemfile
+    @gemfile ||= (
+      require 'yaml'
+      YAML.load(File.new(__DIR__ + '/gemfile'))
+    )
+  end
+
+  def self.profile
+    @profile ||= (
+      require 'yaml'
+      YAML.load(File.new(__DIR__ + '/profile'))
+    )
+  end
+
+  def self.const_missing(name)
+    key = name.to_s.downcase
+    gemfile[key] || profile[key] || super(name)
+  end
+
+end
+

data/lib/lemon/meta/gemfile

@@ -0,0 +1,24 @@
+---
+name     : lemon
+version  : 0.8.2
+date     : 2010-09-05
+
+requires:
+  - name: ae
+    group: runtime
+
+  - name: syckle
+    group: development
+
+  - name: box
+    group: development
+
+  - name: cucumber
+    group: test
+
+  - name: ae
+    group: test
+
+  - name: aruba
+    group: test
+

data/{PROFILE → lib/lemon/meta/profile}

@@ -1,11 +1,10 @@
 --- 
-title: Lemon
-suite: proutils
-copyright: Copyright 2009 Thomas Sawyer
-license: MIT
+title  : Lemon
+suite  : proutils
 summary: Pucker-tight Unit Testing
 authors: Thomas Sawyer
-contact: proutils@googlegroups.com
+contact: trans <transfire@gmail.com>
+license: Apache 2.0
 
 description:
   Lemon is a unit testing framework that tightly correlates
@@ -14,3 +13,5 @@ description:
 resources:
   homepage: http://proutils.github.com/lemon
   repository: git://github.com/proutils/lemon.git
+
+copyright: Copyright 2009 Thomas Sawyer

data/lib/lemon/model/ae.rb

@@ -0,0 +1,4 @@
+require 'ae'
+require 'ae/expect'
+require 'ae/should'
+require 'ae/pry'

data/lib/lemon/model/cover_unit.rb

@@ -0,0 +1,75 @@
+module Lemon
+
+  # Unit of coverage, ecapsulates a method, it's characteristics and a flag
+  # as to whether it has been covered or not.
+  class CoverUnit
+
+    attr :target
+    attr :method
+    attr :function
+
+    def initialize(target, method, props={})
+      @target   = target
+      @method   = method.to_sym
+      @function = props[:function] ? true : false
+      @covered  = props[:covered]
+
+      if @function
+        @private = !@target.public_methods.find{ |m| m.to_sym == @method }
+      else
+        @private = !@target.public_instance_methods.find{ |m| m.to_sym == @method }
+      end
+    end
+
+    # Method access is private or protected?
+    def private?
+      @private
+    end
+
+    # Marked as covered?
+    def covered?
+      @covered
+    end
+
+    #
+    def function?
+      @function
+    end
+
+    #
+    def hash
+      @target.hash ^ @method.hash ^ @function.hash
+    end
+
+    #
+    def to_s
+      if @function
+        "#{@target}.#{@method}"
+      else
+        "#{@target}##{@method}"
+      end
+    end
+    alias to_str to_s
+
+    def eql?(other)
+      return false unless Unit === other
+      return false unless target == other.target
+      return false unless method == other.method
+      return false unless function == other.function
+      return true
+    end
+
+    def inspect
+      "#{target}#{function ? '.' : '#'}#{method}"
+    end
+
+    def <=>(other)
+      c = (target.name <=> other.target.name)
+      return c unless c == 0
+      return -1 if function  && !other.function
+      return  1 if !function && other.function
+      method.to_s <=> other.method.to_s
+    end
+  end
+
+end

data/lib/lemon/{dsl.rb → model/main.rb}

@@ -1,49 +1,42 @@
-# Current suite being defined. This is used
-# to define a Suite object via the toplevel DSL.
-def Lemon.suite
-  @suite
-end
-
-#
-def Lemon.suite=(suite)
-  @suite = suite
-end
+# NOTE: This code is not being used. It is here for the time being
+# on the outseide change that I decide to go back to a toplevel design.
 
-#
-def Before(match=nil, &block)
-  Lemon.suite.Before(match, &block)
-end
+require 'lemon/model/test_suite'
 
 #
-def After(match=nil, &block)
-  Lemon.suite.After(match, &block)
-end
+#def Before(match=nil, &block)
+#  Lemon.suite.Before(match, &block)
+#end
 
 #
-def When(match=nil, &block)
-  Lemon.suite.When(match, &block)
-end
+#def After(match=nil, &block)
+#  Lemon.suite.After(match, &block)
+#end
 
 #
-def Case(target_class, &block)
-  Lemon.suite.Case(target_class, &block)
+def testcase(target_class, &block)
+  Lemon.suite.dsl.testcase(target_class, &block)
 end
-alias :TestCase :Case
+alias :TestCase :testcase
+alias :Case :testcase
+alias :tests :testcase # can't use test b/c of kernel method
 
 #
-def Covers(script)
-  Lemon.suite.Covers(script)
+def covers(script)
+  Lemon.suite.dsl.covers(script)
 end
+alias :Covers :covers
 
 #
-def Helper(script)
-  Lemon.suite.Helper(script)
-end
+#def Helper(script)
+#  Lemon.suite.Helper(script)
+#end
 
 #def Subtest(script)
 #  Lemon.suite.Subtest(script)
 #end
 
+=begin
 # FIXME: This is a BIG FAT HACK! For the life of me I cannot find
 # a way to resolve module constants included in the test cases.
 # Because of closure, the constant lookup goes through here, and not
@@ -79,4 +72,5 @@ end
 def Lemon.test_stack
   @@test_stack ||= []
 end
+=end