lemon 0.8.1 → 0.8.2

data/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/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/meta/profile

@@ -0,0 +1,17 @@
+--- 
+title  : Lemon
+suite  : proutils
+summary: Pucker-tight Unit Testing
+authors: Thomas Sawyer
+contact: trans <transfire@gmail.com>
+license: Apache 2.0
+
+description:
+  Lemon is a unit testing framework that tightly correlates
+  class to test case and method to test unit.
+
+resources:
+  homepage: http://proutils.github.com/lemon
+  repository: git://github.com/proutils/lemon.git
+
+copyright: Copyright 2009 Thomas Sawyer

data/test/api/applique/fs.rb

@@ -0,0 +1,18 @@
+require 'fileutils'
+
+Before :demo do
+  FileUtils.rm_r('tmp')
+end
+
+When "Given an example script in '(((.*?)))' as follows" do |name, text|
+  name = File.join('tmp', name) if /^tmp/ !~ name
+  FileUtils.mkdir_p(File.dirname(name))
+  File.open(name, 'w'){ |w| w << text }
+end
+
+When "given a test case in '(((.*?)))' as follows"  do |name, text|
+  name = File.join('tmp', name) if /^tmp/ !~ name
+  FileUtils.mkdir_p(File.dirname(name))
+  File.open(name, 'w'){ |w| w << text }
+end
+

data/test/api/coverage/complete.rdoc

@@ -0,0 +1,136 @@
+== Complete Coverage
+
+=== Complete Coverage of Public Interface
+
+Given an example script in 'tmp/lib/example.rb' as follows:
+
+    class C1
+      def f1; "f1"; end
+      def f2; "f2"; end
+      def f3; "f3"; end
+    end
+
+    class C2
+      def g1; "g1"; end
+      protected
+      def g2; "g2"; end
+      private
+      def g3; "g3"; end
+    end
+
+And given a test case in 'tmp/test/example_case.rb' as follows:
+
+    covers 'example.rb'
+
+    testcase C1 do
+      unit :f1 => "Returns a String" do
+      end
+      unit :f2 => "Returns a String" do
+      end
+      unit :f3 => "Returns a String" do
+      end
+    end
+
+    testcase C2 do
+      unit :g1 => "Returns a String" do
+      end
+    end
+
+And we get the coverage information via CoverageAnalyer.
+
+    require 'lemon'
+
+    tests = ['tmp/test/example_case.rb']
+
+    coverage = Lemon::CoverageAnalyzer.new(tests, :loadpath=>'tmp/lib')
+
+Then we should see that there are no uncovered units.
+
+    coverage.uncovered_units.assert == []
+
+And there should be 4 covered units,
+
+    coverage.covered_units.size.assert == 4
+
+one for each public class and method.
+
+    units = coverage.covered_units.map{ |u| u.to_s }
+
+    units.assert.include?('C1#f1')
+    units.assert.include?('C1#f2')
+    units.assert.include?('C1#f3')
+
+    units.assert.include?('C2#g1')
+
+There should not be any coverage for private and protected methods.
+
+    units.refute.include?('C2#g2')
+    units.refute.include?('C2#g3')
+
+In addition there should be no uncovered_cases or undefined_units.
+
+    coverage.undefined_units.assert = []
+    coverage.uncovered_cases.assert = []
+
+=== Including Private and Protected Methods
+
+We will use the same example classes as above, but in this case we will
+add coverage for private and protected methods as well, given a test case
+in 'tmp/test/example_case.rb' as follows:
+
+    covers 'example.rb'
+
+    testcase C1 do
+      unit :f1 => "Returns a String" do
+      end
+      unit :f2 => "Returns a String" do
+      end
+      unit :f3 => "Returns a String" do
+      end
+    end
+
+    testcase C2 do
+      unit :g1 => "Returns a String" do
+      end
+      unit :g2 => "Returns a String" do
+      end
+      unit :g3 => "Returns a String" do
+      end
+    end
+
+And we get the coverage information via CoverageAnalyer.
+
+    require 'lemon'
+
+    tests = ['tmp/test/example_case.rb']
+
+    coverage = Lemon::CoverageAnalyzer.new(tests, :loadpath=>'tmp/lib', :private=>true)
+
+Notice the use of the +private+ option. This will add private and protected
+methods to the coverage analysis.
+
+Then we should see that there are no uncovered units.
+
+    coverage.uncovered_units.assert == []
+
+And there should be 6 covered units,
+
+    coverage.covered_units.size.assert == 6
+
+one for each class and method.
+
+    units = coverage.covered_units.map{ |u| u.to_s }
+
+    units.assert.include?('C1#f1')
+    units.assert.include?('C1#f2')
+    units.assert.include?('C1#f3')
+
+    units.assert.include?('C2#g1')
+    units.assert.include?('C2#g2')
+    units.assert.include?('C2#g3')
+
+In addition there should be no uncovered cases or undefined units.
+
+    coverage.undefined_units.assert = []
+    coverage.uncovered_cases.assert = []
+

data/test/api/coverage/extensions.rdoc

@@ -0,0 +1,61 @@
+== Core Extension Coverage
+
+=== Kernel Extensions
+
+Given an example script in 'tmp/lib/example.rb' as follows:
+
+    module Kernel
+      def f1; "f1"; end
+      def f2; "f2"; end
+      def f3; "f3"; end
+    end
+
+And given a test case in 'tmp/test/example_case.rb' as follows:
+
+    covers 'example.rb'
+
+    tests Kernel do
+      unit :f1 do
+        fl.assert == "f1"
+      end
+      unit :f2 do
+        f2.assert == "f2"
+      end
+    end
+
+And we get the coverage information via CoverageAnalyer.
+
+    require 'lemon'
+
+    tests = ['tmp/test/example_case.rb']
+
+    coverage = Lemon::CoverageAnalyzer.new(tests, :loadpath=>'tmp/lib')
+
+Then we should see that there are two covered units, #f1 and #f2.
+
+    coverage.covered_units.size.assert == 2
+
+    units = coverage.covered_units.map{ |u| u.to_s }
+
+    units.assert.include?('Kernel#f1')
+    units.assert.include?('Kernel#f2')
+
+    units.refute.include?('Kernel#f3')
+
+And we should see one unconvered unit, #f3.
+
+    coverage.uncovered_units.size.assert == 1
+
+    units = coverage.uncovered_units.map{ |u| u.to_s }
+
+    units.assert.include?('Kernel#f3')
+
+There should be zero uncovered cases.
+
+    coverage.uncovered_cases == []
+
+And zero undefined unit.
+
+    coverage.undefined_units == []
+
+

data/test/api/coverage/incomplete.rdoc

@@ -0,0 +1,97 @@
+== Incomplete Coverage
+
+=== Incomplete Coverage of Public Interface
+
+Given an example script in 'tmp/lib/example.rb' as follows:
+
+    class C1
+      def f1; "f1"; end
+      def f2; "f2"; end
+      def f3; "f3"; end
+    end
+
+    class C2
+      def g1; "g1"; end
+      protected
+      def g2; "g2"; end
+      private
+      def g3; "g3"; end
+    end
+
+    class C3
+      def h1; "h1"; end
+    end
+
+And given a test case in 'tmp/test/example_case.rb' as follows:
+
+    covers 'example.rb'
+
+    testcase C1 do
+      unit :f1 => "Returns a String" do
+      end
+      unit :f2 => "Returns a String" do
+      end
+    end
+
+    testcase C2 do
+      unit :x1 => "Does not exist" do
+      end
+    end
+
+And we get the coverage information via CoverageAnalyer.
+
+    require 'lemon'
+
+    tests = ['tmp/test/example_case.rb']
+
+    coverage = Lemon::CoverageAnalyzer.new(tests, :loadpath=>'tmp/lib')
+
+Then we should see that there are 2 unconvered units, C1#f3 and C2#g1
+because no testcase unit was defined for them and they are both public methods.
+
+    coverage.uncovered_units.size.assert == 2
+
+    units = coverage.uncovered_units.map{ |u| u.to_s }
+
+    units.assert.include?('C1#f3')
+    units.assert.include?('C2#g1')
+
+You might expect that 'C3#h1' would be in the uncovered units list as well,
+since it is a public method and no test unit covers it. However, there is
+no test case for C3 at all, so Lemon takes that to mean that C3 is of
+no interest.
+
+    units.refute.include?('C3#h1')
+
+But C3 will be listed in the uncovered cases list.
+
+    coverage.uncovered_cases == [C3]
+
+Note that uncovered case methods can be included in the uncovered units list
+by setting the +zealous+ option, which we will demonstrate later.
+
+There should still be 3 covered units, C1#f1, C1#f2 and C2#x1.
+
+    coverage.covered_units.size.assert == 3
+
+    units = coverage.covered_units.map{ |u| u.to_s }
+
+    units.assert.include?('C1#f1')
+    units.assert.include?('C1#f2')
+    units.assert.include?('C2#x1')
+
+But we will not find any covered units for class C2.
+
+    units.refute.include?('C2#g1')
+    units.refute.include?('C2#g2')
+    units.refute.include?('C2#g3')
+
+Notice also that we defined a unit for C2#x1, a method that does not exist.
+So it should be listed in the undefined units list.
+
+    coverage.undefined_units.size.assert == 1
+
+    units = coverage.undefined_units.map{ |u| u.to_s }
+
+    units.assert.include?('C2#x1')
+

data/{features → test/cli}/coverage.feature

@@ -32,7 +32,7 @@ Feature: Coverage
     When I cd to "example"
     And I run "lemon -c -Ilib test/case_complete.rb"
     Then the stdout should contain "0 uncovered cases"
-    And the stdout should contain "0 uncovered units"
+    And the stdout should contain "0/4 uncovered"
     And the stdout should contain "0 undefined units"
 
   Scenario: Incomplete Example Case
@@ -48,7 +48,7 @@ Feature: Coverage
         def q; "q"; end
       end
       """
-    Given a file named "example/test/case_complete.rb" with:
+    Given a file named "example/test/case_incomplete.rb" with:
       """
       Covers 'example'
       TestCase X do
@@ -58,8 +58,8 @@ Feature: Coverage
       end
       """
     When I cd to "example"
-    And I run "lemon -c -Ilib test/case_complete.rb"
+    And I run "lemon -c -Ilib test/case_incomplete.rb"
     Then the stdout should contain "1 uncovered cases"
-    And the stdout should contain "1 uncovered units"
+    And the stdout should contain "1/4 uncovered"
     And the stdout should contain "1 undefined units"
 

data/{features → test/cli}/generate.feature

@@ -1,8 +1,8 @@
 Feature: Coverage
   As a developer
   In order to improve test coverge
-  I want to able to write unit tests that target methods
-  And run those tests
+  I want to able to generate test scaffolding
+  And limit the scaffolding to test units not already covered
 
   Scenario: Complete Example Case
     Given a directory named "example"

data/test/fixtures/case_complete.rb

@@ -1,8 +1,21 @@
-Covers File.dirname(__FILE__) + '/example.rbx'
-TestCase X do
-  Unit :a => "Returns a String" do
+covers File.dirname(__FILE__) + '/example.rb'
+
+testcase X do
+
+  unit :a => "Returns a String" do
   end
-  Unit :b => "Returns a String" do
+
+  unit :b => "Returns a String" do
+  end
+
+  unit :c => "Returns a String" do
   end
+
 end
 
+testrcase Y do
+
+  unit :q => "Returns a String" do
+  end
+
+end