lemon 0.7.0 → 0.8.0

data/HISTORY

@@ -1,17 +1,20 @@
 = RELEASE HISTORY
 
+== 0.8.0 / 2010-06-21
+
+This release removes coverage information from testing. Coverage can be time consuming, but running test should be as fast as possbile. For this reason coverage and testing are kept two independent activities. This release also adds some test coverage for Lemon itself via Cucumber.
+
+Changes:
+
+* Separated coverage from testing completely.
+* Test generator defaults to public methods only.
+
+
 == 0.7.0 / 2010-05-04
 
-This release fixes issue with coverage reports. To do this
-we have interoduced the +Covers+ method. This allows Lemon
-to distingush between code that is inteded to be covered
-by the tests and mere support code.
+This release fixes issue with coverage reports. To do this we have interoduced the +Covers+ method. This allows Lemon to distingush between code that is inteded to be covered by the tests and mere support code.
 
-Keep in mind that there is no perfect way to handle coverage.
-Even with the distiction the +Covers+ method provides, coverage
-might not be reported exactly as desired. Other techinques can
-be used to refine coverage however, such a preloading embedded
-support libraries.
+Keep in mind that there is no perfect way to handle coverage. Even with the distiction the +Covers+ method provides, coverage might not be reported exactly as desired. Other techinques can be used to refine coverage however, such a preloading embedded support libraries.
 
 Changes:
 
@@ -21,8 +24,7 @@ Changes:
 
 == 0.6.0 / 2010-03-06
 
-This release adds coverage reporting to testing and improves
-the generator.
+This release adds coverage reporting to testing and improves the generator.
 
 Changes:
 
@@ -33,10 +35,7 @@ Changes:
 
 == 0.5.0 / 2009-12-31
 
-This is the initial public release of Lemon. Lemon is
-still under development and should be considered betaware,
-but it's API is stable and the system usable enough to 
-warrant a release.
+This is the initial public release of Lemon. Lemon is still under development and should be considered betaware, but it's API is stable and the system usable enough to warrant a release.
 
 Changes:
 

data/PROFILE

@@ -0,0 +1,16 @@
+--- 
+title: Lemon
+suite: proutils
+copyright: Copyright 2009 Thomas Sawyer
+license: MIT
+summary: Pucker-tight Unit Testing
+authors: Thomas Sawyer
+contact: proutils@googlegroups.com
+
+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

data/README.rdoc

@@ -6,16 +6,9 @@
 
 == 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.
+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, lies in where the
-*concern* lies. The concern of unit testing are the concerns
-of unit tests -- the individual methods.
+The difference between unit testing and functional testing, and all other forms of testing for that matter, lies in where the *concern* lies. The concern of unit testing are the concerns of unit tests -- the individual methods.
 
 
 == HOW TO USE
@@ -39,12 +32,9 @@ The simplist test case would be written as follows:
     end
   end
 
-The +Covers+ method works just like +require+ with the exception
-that loading the file does not occur until just before the tests
-are run. This allows Lemon to cacluate accurate coverage reports.
+The +Covers+ method works just like +require+ with the exception that loading the file does not occur until just before the tests are run. This allows Lemon to cacluate accurate coverage reports.
 
-As tests grow, we might need to organize them into special concerns.
-For this Lemon provides the #Concern method.
+As tests grow, we might need to organize them into special concerns. For this Lemon provides the #Concern method.
 
   Covers 'mylib'
 
@@ -63,35 +53,23 @@ 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 <tt>--verbose</tt> or <tt>-v</tt> option.
+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
 
 === Checking Test Coverage
 
-Lemon can check test coverage by loading your target system and 
-comparing it to your tests.
+Lemon can check test coverage by loading your target system and comparing it to your tests. To do this suppy the <code>lemon</code> command the <code>--coverage</code> or <code>-c</code> option.
 
   $ lemon --coverage -Ilib test/cases/
 
 === Generating Test Skeletons
 
-Because of the one to one correspondance of case-unit to class-method, Lemon can
-also generate test scaffolding for previously written code. To do this, use the
-<tt>--generate</tt> 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.
+Because of the one to one correspondance 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 --generate -Ilib test/cases/
 
-Generating test case scaffodling 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 protions of code, or for achieving full test coverage for mission critical
-applications.
+Generating test case scaffodling 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 protions of code, or for achieving full test coverage for mission critical applications.
 
 
 == COPYRIGHT

data/REQUIRE

@@ -0,0 +1,9 @@
+development:
+  - syckle
+  - box
+
+development/test:
+  - cucumber
+  - ae
+  - aruba
+

data/VERSION

@@ -0,0 +1,6 @@
+---
+name : lemon
+major: 0
+minor: 8
+patch: 0
+date : 2010-06-21

data/features/coverage.feature

@@ -0,0 +1,65 @@
+Feature: Coverage
+  As a developer
+  In order to improve test coverge
+  I want to able to write tests with coverage in mind
+  And receive effective coverage reports
+
+  Scenario: Complete Example Case
+    Given a directory named "example"
+    Given a file named "example/lib/example.rb" with:
+      """
+      class X
+        def a; "a"; end
+        def b; "b"; end
+        def c; "c"; end
+      end
+      class Y
+        def q; "q"; end
+      end
+      """
+    Given a file named "example/test/case_complete.rb" with:
+      """
+      Covers 'example'
+      TestCase X do
+        Unit :a => "Returns a String" do ; end
+        Unit :b => "Returns a String" do ; end
+        Unit :c => "Returns a String" do ; end
+      end
+      TestCase Y do
+        Unit :q => "Returns a String" do ; end
+      end
+      """
+    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 undefined units"
+
+  Scenario: Incomplete Example Case
+    Given a directory named "example"
+    Given a file named "example/lib/example.rb" with:
+      """
+      class X
+        def a; "a"; end
+        def b; "b"; end
+        def c; "c"; end
+      end
+      class Y
+        def q; "q"; end
+      end
+      """
+    Given a file named "example/test/case_complete.rb" with:
+      """
+      Covers 'example'
+      TestCase X do
+        Unit :a => "Returns a String" do ; end
+        Unit :b => "Returns a String" do ; end
+        Unit :d => "Returns a String" do ; end
+      end
+      """
+    When I cd to "example"
+    And I run "lemon -c -Ilib test/case_complete.rb"
+    Then the stdout should contain "1 uncovered cases"
+    And the stdout should contain "1 uncovered units"
+    And the stdout should contain "1 undefined units"
+

data/features/generate.feature

@@ -0,0 +1,66 @@
+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
+
+  Scenario: Complete Example Case
+    Given a directory named "example"
+    Given a file named "example/lib/example.rb" with:
+      """
+      class X
+        def a; "a"; end
+        def b; "b"; end
+        def c; "c"; end
+      end
+      class Y
+        def q; "q"; end
+      end
+      """
+    Given a file named "example/test/case_complete.rb" with:
+      """
+      Covers 'example'
+      TestCase X do
+        Unit :a => "Returns a String" do ; X.new.a.assert.is_a?(String) ; end
+        Unit :b => "Returns a String" do ; X.new.b.assert.is_a?(String) ; end
+        Unit :c => "Returns a String" do ; X.new.c.assert.is_a?(String) ; end
+      end
+      TestCase Y do
+        Unit :q => "Returns a String" do ; Y.new.q.assert.is_a?(String) ; end
+      end
+      """
+    When I cd to "example"
+    And I run "lemon -g -u -Ilib test/case_complete.rb"
+    Then the stdout should not contain "Unit :a"
+    And the stdout should not contain "Unit :b"
+    And the stdout should not contain "Unit :c"
+    And the stdout should not contain "Unit :q"
+
+  Scenario: Incomplete Example Case
+    Given a directory named "example"
+    Given a file named "example/lib/example.rb" with:
+      """
+      class X
+        def a; "a"; end
+        def b; "b"; end
+        def c; "c"; end
+      end
+      class Y
+        def q; "q"; end
+      end
+      """
+    Given a file named "example/test/case_complete.rb" with:
+      """
+      Covers 'example'
+      TestCase X do
+        Unit :a => "Returns a String" do ; X.new.a.assert.is_a?(String) ; end
+        Unit :b => "Returns a String" do ; X.new.b.assert.is_a?(Fixnum) ; end
+        Unit :d => "Returns a String" do ; X.new.d.assert.is_a?(String) ; end
+      end
+      """
+    When I cd to "example"
+    And I run "lemon -g -u -Ilib test/case_complete.rb"
+    Then the stdout should not contain "Unit :a"
+    And the stdout should not contain "Unit :b"
+    And the stdout should contain "Unit :c"
+

data/features/step_definitions/coverage_steps.rb

@@ -0,0 +1 @@
+

data/features/support/ae.rb

@@ -0,0 +1 @@
+require 'ae'

data/features/support/aruba.rb

@@ -0,0 +1 @@
+require 'aruba'

data/features/test.feature

@@ -0,0 +1,67 @@
+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
+
+  Scenario: Complete Example Case
+    Given a directory named "example"
+    Given a file named "example/lib/example.rb" with:
+      """
+      class X
+        def a; "a"; end
+        def b; "b"; end
+        def c; "c"; end
+      end
+      class Y
+        def q; "q"; end
+      end
+      """
+    Given a file named "example/test/case_complete.rb" with:
+      """
+      Covers 'example'
+      TestCase X do
+        Unit :a => "Returns a String" do ; X.new.a.assert.is_a?(String) ; end
+        Unit :b => "Returns a String" do ; X.new.b.assert.is_a?(String) ; end
+        Unit :c => "Returns a String" do ; X.new.c.assert.is_a?(String) ; end
+      end
+      TestCase Y do
+        Unit :q => "Returns a String" do ; Y.new.q.assert.is_a?(String) ; end
+      end
+      """
+    When I cd to "example"
+    And I run "lemon -Ilib -v test/case_complete.rb"
+    Then the stdout should contain "4 tests"
+    And the stdout should contain "4 pass"
+    And the stdout should contain "0 fail"
+    And the stdout should contain "0 err"
+
+  Scenario: Incomplete Example Case
+    Given a directory named "example"
+    Given a file named "example/lib/example.rb" with:
+      """
+      class X
+        def a; "a"; end
+        def b; "b"; end
+        def c; "c"; end
+      end
+      class Y
+        def q; "q"; end
+      end
+      """
+    Given a file named "example/test/case_complete.rb" with:
+      """
+      Covers 'example'
+      TestCase X do
+        Unit :a => "Returns a String" do ; X.new.a.assert.is_a?(String) ; end
+        Unit :b => "Returns a String" do ; X.new.b.assert.is_a?(Fixnum) ; end
+        Unit :d => "Returns a String" do ; X.new.d.assert.is_a?(String) ; end
+      end
+      """
+    When I cd to "example"
+    And I run "lemon -Ilib -v test/case_complete.rb"
+    Then the stdout should contain "3 tests"
+    And the stdout should contain "1 pass"
+    And the stdout should contain "1 fail"
+    And the stdout should contain "1 err"
+

data/lib/lemon.rb

@@ -1 +1,2 @@
 require 'lemon/runner'
+require 'lemon/coverage'

data/lib/lemon/command.rb

@@ -1,22 +1,184 @@
-require 'lemon/command/test'
-require 'lemon/command/coverage'
-require 'lemon/command/generate'
-
 module Lemon
-module Command
-
-  # Factory method to initialize and run choosen sub-command.
-  def self.run
-    cmd = Abstract.commands.find do |command_class|
-      /^#{ARGV.first}/ =~ command_class.subcommand
-      #[command_class.options].flatten.find do |subcmd|
-      #  #ARGV.delete(opt)
-      #  /^#{ARGV.first}/ =~ subcmd
-      #end
-    end
-    ARGV.shift if cmd
-    cmd ? cmd.run : Command::Test.run
+  require 'lemon'
+  require 'optparse'
+
+  # Lemon Command-line tool.
+  class Command
+
+    # Initialize and run.
+    def self.run
+      new.run
+    end
+
+    # New Command instance.
+    def initialize
+      @command     = :test
+      @format      = nil
+      @requires    = []
+      @includes    = []
+      @namespaces  = []
+      @uncovered   = false
+      @public_only = true
+    end
+
+    #
+    attr_accessor :command
+
+    #
+    attr_accessor :format
+
+    #
+    attr_accessor :requires
+
+    #
+    attr_accessor :includes
+
+    #
+    attr_accessor :namespaces
+
+    #
+    attr_accessor :uncovered
+
+    #
+    attr_accessor :public_only
+
+
+    # Get or set librarires to pre-require.
+    def requires(*paths)
+      @requires.concat(paths) unless paths.empty?
+      @requires
+    end
+
+    # Get or set paths to include in $LOAD_PATH.
+    def includes(*paths)
+      @includes.concat(paths) unless paths.empty?
+      @includes
+    end
+
+    #
+    def namespaces(*names)
+      @namespaces.concat(names) unless names.empty?
+      @namespaces
+    end
+
+    # Instance of OptionParser.
+    def parser
+      @parser ||= OptionParser.new do |opt|
+        opt.banner = "lemon [options] [files ...]"
+        opt.separator("Run unit tests, check coverage and generate test scaffolding.")
+        opt.separator " "
+        opt.separator("COMMAND OPTIONS (choose one):")
+        opt.on('--test', '-t', "run unit tests [default]") do
+          self.command = :test
+        end
+        opt.on('--coverage', '-c', "provide test coverage analysis") do
+          self.command = :cover
+        end
+        opt.on('--generate', '-g', "generate unit test scaffolding") do
+          self.command = :generate
+        end
+        opt.separator " "
+        opt.separator("COMMON OPTIONS:")
+        opt.on("--namespace", "-n NAME", "limit testing/coverage to namespace") do |name|
+          namespaces(name)
+        end
+        opt.on('--format', '-f TYPE', "select output format") do |type|
+          self.format = type
+        end
+        opt.on('--verbose', '-v', "select verbose report format") do |type|
+          self.format = :verbose
+        end
+        opt.on('--outline', '-o', "select outline report format") do |type|
+          self.format = :outline
+        end
+        opt.separator " "
+        opt.separator("COVERAGE OPTIONS:")
+        opt.on('--private', '-p', "include private and protected methods") do
+          self.public_only = false
+        end
+        opt.separator " "
+        opt.separator("GENERATOR OPTIONS:")
+        opt.on("--uncovered", "-u", "only include missing units of uncovered methods") do
+          self.uncovered = true
+        end
+         opt.separator " "
+        opt.separator("SYSTEM OPTIONS:")
+        opt.on("-r [FILES]" , 'files to require (before doing anything else)') do |files|
+          files = files.split(/[:;]/)
+          requires(*files)
+        end
+        opt.on("-I [PATH]" , 'locations to add to $LOAD_PATH') do |path|
+          paths = path.split(/[:;]/)
+          includes(*paths)
+        end
+        opt.on("--debug" , 'turn on debugging mode') do
+          $DEBUG = true
+        end
+        opt.on_tail('--help', '-h', 'show this help message') do
+          puts opt
+          exit
+        end
+      end
+    end
+
+    # Run command.
+    def run
+      parser.parse!
+      __send__(@command)
+    end
+
+    # Run unit tests.
+    def test
+      require 'lemon/runner'
+
+      files = ARGV.dup
+
+      includes.each{ |path| $LOAD_PATH.unshift(path) }
+      requires.each{ |path| require(path) }
+
+      #suite  = Lemon::Test::Suite.new(files, :cover=>cover)
+      #runner = Lemon::Runner.new(suite, :format=>format, :cover=>cover, :namespaces=>namespaces)
+
+      suite  = Lemon::Test::Suite.new(files)
+      runner = Lemon::Runner.new(suite, :format=>format, :namespaces=>namespaces)
+
+      runner.run
+    end
+
+    # Ouput coverage report.
+    def cover
+      test_files = ARGV.dup
+      load_files = []
+
+      includes.each{ |path| $LOAD_PATH.unshift(path) }
+      requires.each{ |path| require(path) }
+
+      suite    = Lemon::Test::Suite.new(test_files, :cover=>true)
+      coverage = Lemon::Coverage.new(suite, namespaces, :public=>public_only)
+
+      coverage.format(format)
+    end
+
+    # Generate test templates.
+    def generate
+      test_files = ARGV.dup
+
+      includes.each{ |path| $LOAD_PATH.unshift(path) }
+      requires.each{ |path| require(path) }
+
+      suite = Lemon::Test::Suite.new(test_files, :cover=>true, :cover_all=>true)
+      cover = Lemon::Coverage.new(suite, namespaces, :public=>public_only)
+      #cover  = Lemon::Coverage.new([], namespaces, :public=>public_only?, :uncovered=>uncovered)
+
+      if uncovered
+        puts cover.generate_uncovered #(output)
+      else
+        puts cover.generate #(output)
+      end
+
+    end
+
   end
 
 end
-end
+