lemon 0.8.5 → 0.9.0

data/README.rdoc

@@ -1,103 +0,0 @@
-= Lemon
-
-* Homepage[http://rubyworks.github.com/lemon]
-* Development[http://github.com/rubyworks/lemon]
-* Issues[http://github.com/rubyworks/lemon/issues]
-
-
-== DESCRIPTION
-
-Lemon is a Unit Testing Framework that enforces a test case construction mirroring the class/module and method design of the target system. Arguably this promotes the proper technique for unit testing and helps ensure good test coverage.
-
-The difference between unit testing and functional testing, and all other forms of testing for that matter, is simply a matter of where the *concern* lies. The concerns of unit testing are the concerns of unit tests -- the individual methods.
-
-
-== HOW TO USE
-
-=== Writing Tests
-
-Say our library 'mylib.rb' consists of the class X:
-
-  class X
-    def a; "a"; end
-  end
-
-The simplest test case would be written as follows:
-
-  covers 'mylib'
-
-  testcase X do
-    unit :a => "method #a does something expected" do
-      x = X.new
-      x.a.assert.is_a? String
-    end
-  end
-
-The +Covers+ method works just like +require+ with the exception that Lemon records the file for reference --under certain scenarios it can be used to improve overall test covered.
-
-As tests grow, we might need to organize them into special concerns. For this Lemon provides a #concern method and a #setup method. Technically the two methods are the same, but #concern is used more for descriptive purposes whereas #setup is used to create an instance of the testcase's target class.
-
-  covers 'mylib'
-
-  testcase X do
-    setup "Description of a concern that the following unit tests address." do
-      X.new
-    end
-
-    unit :a => "method #a does something expected" do |x|
-      x.a.assert.is_a? String
-    end
-  end
-
-Notice that the parameter passed to the block of +unit+ method is the instance of +X+ created in the +setup+ block. This block is run for every subsequent +Unit+ until a new concern is defined.
-
-In conjunction with the #setup methods, there is a #teardown method which can be used "tidy-up" after each unit run if need be.
-
-Lastly, there are the +before+ and +after+ methods which can be used only once for each testcase. The +before+ method defines a procedure to run before any of the testcase's units are run, and the +after+ method defines a procedure to run after that are all finished.
-
-That is the bulk of the matter for writing Lemon tests. There are few other features not mentions here. You can learn more about hose by reading the wiki[http://wiki.github.com/proutils/lemon].
-
-
-=== Running Tests
-
-To run tests use the +lemon+ command-line utility.
-
-  $ lemon test/cases/name_case.rb
-
-Normal output is typical <i>dot-progress</i>. For verbose output, use the <code>--verbose</code> or <code>-v</code> option.
-
-  $ lemon -v test/cases/name_case.rb
-
-Other output types can be specified by the `--format` or `-f` option.
-
-  $ lemon -f tap test/cases/name_case.rb
-
-
-=== Checking Test Coverage
-
-Lemon can check test coverage by loading your target system and comparing it to your tests. To do this supply the <code>lemon</code> command the <code>--coverage</code> or <code>-c</code> option.
-
-  $ lemon -c -Ilib test/cases/*.rb
-
-=== Generating Test Skeletons
-
-Because of the one to one correspondence of case-unit to class-method, Lemon can also generate test scaffolding for previously written code. To do this, use the <code>--generate</code> or <code>-g</code> option and provide the lib location, or files, of the scripts for which to generate test scaffolding, and the output location for the test scripts.
-
-  $ lemon -g -Ilib test/cases/*.rb
-
-Generating test case scaffolding from code will undoubtedly strike test-driven developers as a case of putting the cart before the horse. However, it is not unreasonable to argue that high-level, behavior-driven, functional testing frameworks, such as Q.E.D. and Cucumber are better suited to test-first methodologies. While test-driven development can obviously be done with Lemon, unit-testing is more appropriate for testing specific, critical portions of code, or for achieving full test coverage for mission critical applications.
-
-=== Test Directory
-
-There is no special directory for Lemon tests. Since they are unit tests, `test/` or `test/unit/` are good choices. Other options are `cases/` and `test/cases` since each file generally defines a single testcase. However, I recommend using interface-based names, regardless of the framework you actually use. In which case, `test/unit` is still a good choice, but also `test/api` if Lemon will be the only framework you use to test the API directly.
-
-
-== COPYRIGHT
-
-Lemon Unit Testing Framework
-
-Copyright (c) 2009 Thomas Sawyer 
-
-BSD 2 Clause License
-
-See COPYING.rdoc for details.

data/bin/lemon

@@ -1,4 +0,0 @@
-#!/usr/bin/env ruby
-require 'lemon'
-Lemon::CLI.run(ARGV)
-

data/demo/case_example_error.rb

@@ -1,10 +0,0 @@
-covers File.dirname(__FILE__) + '/fixture/example.rb'
-
-testcase Example do
-
-  unit :f => "one and one is two"do
-    ExampleUnknown.new.f(1,1).assert == 2
-  end
-
-end
-

data/demo/case_example_fail.rb

@@ -1,15 +0,0 @@
-covers File.dirname(__FILE__) + '/fixture/example.rb'
-
-testcase Example do
-
-  unit :f => "one and one is two"do
-    Example.new.f(1,1).assert == 2
-  end
-
-  unit :f do
-    ex = Example.new
-    ex.f(1,2).assert == 4
-  end
-
-end
-

data/demo/case_example_pass.rb

@@ -1,32 +0,0 @@
-covers File.dirname(__FILE__) + '/fixture/example.rb'
-
-testcase Example do
-
-  setup "without multipler" do
-    Example.new
-  end
-
-  unit :f do |ex|
-    ex.f(1,2).assert == 3
-    ex.f(2,2).assert == 4
-  end
-
-  setup "with multipler" do
-    Example.new(2)
-  end
-
-  unit :f => "incorporate the multiplier" do |ex|
-    ex.f(1,2).assert == 4
-    ex.f(2,2).assert == 6
-  end
-
-  teardown do
-    # ...
-  end
-
-  meta :m do
-    Example.m(1,1).assert == 1
-  end
-
-end
-

data/demo/case_example_pending.rb

@@ -1,14 +0,0 @@
-covers File.dirname(__FILE__) + '/fixture/example.rb'
-
-testcase Example do
-
-  unit :f => "one and one is two"do
-    Example.new.f(1,1).assert == 2
-  end
-
-  unit :f do
-    raise Pending
-  end
-
-end
-

data/demo/case_example_untested.rb

@@ -1,10 +0,0 @@
-covers File.dirname(__FILE__) + '/fixture/example.rb'
-
-testcase Example do
-
-  unit :f do
-    # notice Example#f has not been called
-  end
-
-end
-

data/lib/lemon/controller/test_runner.rb

@@ -1,299 +0,0 @@
-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
-
-    # Samples
-    #
-    # * .lemon/rc
-    # * .lemon/rc.rb
-    # * .config/lemon/rc
-    # * .config/lemon/rc.rb
-    #
-    RC_GLOB = '{.,.config/,config/}lemon/rc{,.rb}'
-
-    #
-    def initialize_rc
-      if file = Dir[RC_GLOB].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.
-    #
-    # @return [Boolean] 
-    #   Whether tests ran without error or failure.
-    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)
-      return record[:error].size + record[:fail].size > 0 ? false : true
-    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 <<-END, unit.procedure.binding
-          raise #{error.class}, "#{unit.target} not tested"
-        END
-      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 === exception ? exception.backtrace : exception)
-      trace = trace.reject{ |t| t =~ /bin\/lemon/ }
-      trace = trace.reject{ |t| t =~ EXCLUDE }
-      if trace.empty?
-        exception
-      else
-        exception.set_backtrace(trace) if Exception === exception
-        exception
-      end
-    end
-
-  end
-
-end
-