lemon 0.8.5 → 0.9.0

data/.ruby

@@ -9,6 +9,7 @@ copyrights:
 replacements: []
 conflicts: []
 requirements:
+- name: test
 - name: ae
 - name: ansi
   version: 1.3+
@@ -24,14 +25,6 @@ requirements:
   groups:
   - test
   development: true
-- name: cucumber
-  groups:
-  - test
-  development: true
-- name: aruba
-  groups:
-  - test
-  development: true
 dependencies: []
 repositories:
 - uri: git://github.com/proutils/lemon.git
@@ -47,10 +40,10 @@ extra:
 alternatives: []
 revision: 0
 title: Lemon
-suite: proutils
 summary: Pucker-tight Unit Testing
 description: Lemon is a unit testing framework that tightly correlates class to test
   case and method to test unit.
-version: 0.8.5
+organization: RubyWorks
+version: 0.9.0
 name: lemon
-date: '2011-07-16'
+date: '2011-08-11'

data/Assembly

@@ -22,22 +22,16 @@ yard:
   yardopts: true  
   priority: 2
 
+qed:
+  files: spec
+
 qedoc:
   title: Lemony Testing
+  files: spec
   output: QED.rdoc
 
-cucumber:
-  service : Custom
-  test    : |
-    system 'cucumber -q -f progress test/cli'
-
-lemon:
-  service : Custom
-  test    : |
-    system 'lemon -Itest/fixtures test/*.rb'
-
 vclog:
-  output   : 
+  output: 
     - log/AHISTORY.rdoc
     - log/CHANGELOG.rdoc
 

data/HISTORY.rdoc

@@ -1,5 +1,36 @@
 = RELEASE HISTORY
 
+== 0.9.0 / 2011-08-11
+
+Version 0.9 is a huge release for Lemon. This release finally makes the transition
+to the new unit subcase syntax --a bit more verbose than the old style but a more
+flexible means of notating unit tests allowing each unit to group together mutiple
+tests. For previous users you will need to change old style tests, e.g.
+
+  Unit :to_s => "that string" do
+    ...
+  end
+
+To the new style:
+
+  Unit :to_s do
+    Test "that string" do
+      ...
+    end
+  end
+
+This release also moves Lemon over to the new Ruby Test library for test runs.
+The `lemon` command line interface has changed and now uses subcommands rather than command
+opitions. So use `lemon coverage` instead of the old `lemon -c`. Since Lemon now uses Ruby
+Test to run tests, `lemon test` is equivalent to `ruby-test`, and the Ruby Test config file
+should be used to configure test runs instead of `.lemonrc` which is no longer supported.
+
+Changes:
+
+* Utilize Ruby Test for test execution.
+* Implemented new unit block syntax.
+
+
 == 0.8.5 / 2011-07-15
 
 This release fixes exit code status, which should be -1 if there

data/MANIFEST

@@ -1,65 +1,55 @@
-#!mast .yardopts .ruby bin demo features lib man qed spec test [A-Z][A-Z]*
+#!mast .yardopts .ruby bin demo lib man qed spec test try [A-Z][A-Z]*
 .yardopts
 .ruby
-bin/lemon
-demo/case_example_error.rb
-demo/case_example_fail.rb
-demo/case_example_pass.rb
-demo/case_example_pending.rb
-demo/case_example_untested.rb
-demo/fixture/example-use.rb
-demo/fixture/example.rb
-features/coverage.feature
-features/generate.feature
-features/step_definitions/coverage_steps.rb
-features/support/ae.rb
-features/support/aruba.rb
-features/test.feature
+bin/lemonade
+lib/lemon/ae.rb
+lib/lemon/cli/base.rb
+lib/lemon/cli/coverage.rb
+lib/lemon/cli/generate.rb
+lib/lemon/cli/test.rb
 lib/lemon/cli.rb
-lib/lemon/controller/coverage_analyzer.rb
-lib/lemon/controller/scaffold_generator.rb
-lib/lemon/controller/test_runner.rb
-lib/lemon/model/ae.rb
-lib/lemon/model/cover_unit.rb
-lib/lemon/model/main.rb
-lib/lemon/model/pending.rb
-lib/lemon/model/snapshot.rb
-lib/lemon/model/source_parser.rb
-lib/lemon/model/test_case.rb
-lib/lemon/model/test_context.rb
-lib/lemon/model/test_suite.rb
-lib/lemon/model/test_unit.rb
-lib/lemon/view/cover_reports/abstract.rb
-lib/lemon/view/cover_reports/compact.rb
-lib/lemon/view/cover_reports/outline.rb
-lib/lemon/view/cover_reports/verbose.rb
-lib/lemon/view/cover_reports/yaml.rb
-lib/lemon/view/test_reports/abstract.rb
-lib/lemon/view/test_reports/dotprogress.rb
-lib/lemon/view/test_reports/html.rb
-lib/lemon/view/test_reports/outline.rb
-lib/lemon/view/test_reports/summary.rb
-lib/lemon/view/test_reports/tap.rb
-lib/lemon/view/test_reports/tapj.rb
-lib/lemon/view/test_reports/tapy.rb
-lib/lemon/view/test_reports/verbose.rb
+lib/lemon/core_ext/kernel.rb
+lib/lemon/core_ext/omission.rb
+lib/lemon/core_ext.rb
+lib/lemon/coverage/analyzer.rb
+lib/lemon/coverage/cover_unit.rb
+lib/lemon/coverage/formats/abstract.rb
+lib/lemon/coverage/formats/compact.rb
+lib/lemon/coverage/formats/outline.rb
+lib/lemon/coverage/formats/verbose.rb
+lib/lemon/coverage/formats/yaml.rb
+lib/lemon/coverage/snapshot.rb
+lib/lemon/coverage/source_parser.rb
+lib/lemon/generator.rb
+lib/lemon/test_advice.rb
+lib/lemon/test_case.rb
+lib/lemon/test_class.rb
+lib/lemon/test_method.rb
+lib/lemon/test_module.rb
+lib/lemon/test_proc.rb
+lib/lemon/test_setup.rb
+lib/lemon/test_world.rb
 lib/lemon.rb
 lib/lemon.yml
-qed/applique/fs.rb
-qed/coverage/01_complete.rdoc
-qed/coverage/02_incomplete.rdoc
-qed/coverage/03_extensions.rdoc
-test/case_coverage_analyzer.rb
-test/case_test_case_dsl.rb
-test/fixtures/case_complete.rb
-test/fixtures/case_inclusion.rb
-test/fixtures/case_incomplete.rb
-test/fixtures/example.rb
-test/fixtures/helper.rb
-test/runner
+spec/applique/fs.rb
+spec/coverage/01_complete.rdoc
+spec/coverage/02_incomplete.rdoc
+spec/coverage/03_extensions.rdoc
+spec/coverage/applique/lemon.rb
+try/.test
+try/case_error.rb
+try/case_fail.rb
+try/case_pass.rb
+try/case_pending.rb
+try/case_singleton.rb
+try/case_untested.rb
+try/fixtures/calculator.rb
+try/fixtures/example-use.rb
+try/fixtures/example.rb
+try/helpers/loadpath.rb
 HISTORY.rdoc
 PROFILE
-README.rdoc
 QED.rdoc
+README.md
 VERSION
 COPYING.rdoc

data/PROFILE

@@ -1,6 +1,5 @@
 --- 
 title  : Lemon
-suite  : proutils
 summary: Pucker-tight Unit Testing
 authors:
   - Thomas Sawyer <transfire@gmail.com>
@@ -16,15 +15,16 @@ resources:
 repositories:
   origin: git://github.com/proutils/lemon.git
 
-copyright: Copyright 2009 Thomas Sawyer
-license: BSD-2-Clause
-
 requirements:
+  - test
   - ae
   - ansi 1.3+
   - detroit  (build)
   - reap     (build)
   - qed      (test)
-  - cucumber (test)
-  - aruba    (test)
+
+organization: RubyWorks
+
+copyright: Copyright 2009 Thomas Sawyer
+license: BSD-2-Clause
 

data/README.md

@@ -0,0 +1,113 @@
+# Lemon
+
+[Homepage](http://rubyworks.github.com/lemon) |
+[User Guide](http://wiki.github.com/rubyworks/lemon) |
+[Development](http://github.com/rubyworks/lemon) |
+[Issues](http://github.com/rubyworks/lemon/issues)
+
+
+## DESCRIPTION
+
+Lemon is a Unit Testing Framework that enforces a strict test structure mirroring the class/module and method structure of the target code. Arguably this promotes the proper technique for low-level 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 testing *concern* lies. The concerns of unit testing are the concerns of unit tests --the individual methods.
+
+IMPORTANT! As of v0.9+ the API has changed. The `unit :name => "description"` notation is no longer supported.
+
+
+## EXAMPLE
+
+Lemon tests are broken down into target class or module and target methods.
+Withn these lie the acutal tests.
+
+Let's say we have a script 'mylib.rb' consisting of the class X:
+
+``` ruby
+class X
+  def a; "a"; end
+end
+```
+
+An test case for the class would be written:
+
+``` ruby
+Covers 'mylib'
+
+TestCase X do
+
+  Setup "Description of setup." do
+    @x = X.new
+  end
+
+  Unit :a do
+    Test "method #a does something expected" do
+      @x.a.assert.is_a? String
+    end
+
+    Test "method #a does something else expected" do
+      @x.a.assert == "x"
+    end
+  end
+
+end
+```
+
+The `covers` method works just like `require` with the exception that it records the file for reference --under certain scenarios it can be used to improve test coverage analysis.
+
+The setup (also called the *concern*) is run for every subsequent test until a new setup is defined.
+
+In conjunction with the `#setup` method, there is a `#teardown` method which can be used "tidy-up" after each test if need be.
+
+You might have also notice by the documentation that the test methods do not have to be capitalized.
+
+That is the bulk of the matter for writing Lemon tests. To learn about additonal features not mentioned here, check-out the [User Guide](http://wiki.github.com/rubyworks/lemon).
+
+
+## USAGE
+
+### Running Tests
+
+Tests can be run using the `lemonade` command line tool.
+
+    $ lemonade test test/cases/name_case.rb
+
+Lemon utilizes the Ruby Test system to run tests, the `lemonade test` command simply passes off the running of tests to `ruby-test`. So the `ruby-test` command-line utility can also be used directly:
+
+    $ ruby-test -r lemon test/cases/name_case.rb
+
+Normal output is typical _dot-progress_. Other output types can be specified by the `--format` or `-f` option.
+
+    $ ruby-test -r lemon -f tap test/cases/name_case.rb
+
+See [Ruby Test](http://rubyworks.github.com/test) for more information.
+
+### Checking Test Coverage
+
+Lemon can check test coverage by loading your target system and comparing it to your tests. To do this use the <code>lemonade coverage</code> command the utility.
+
+    $ lemonade coverage -Ilib test/cases/*.rb
+
+The coverage tool provides class/module and method coverage and is meant to as a "guidance system" for developers working toward complete test coverage. It is not an lines-of-code coverage tool and should not be considered a substitute for one.
+
+### Generating Test Skeletons
+
+Because of the one to one correspondence of test case and unit test to class/module and method, Lemon can also generate test scaffolding for previously written code. To do this, use the <code>lemonade generate</code> command line utility and provide the lib location or files of the scripts for which to generate test scaffolding, and the output location for the test scripts.
+
+    $ lemonade generate -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 test case.
+
+
+## COPYRIGHTS
+
+Lemon Unit Testing Framework
+
+Copyright (c) 2009 Thomas Sawyer 
+
+Lemon is distributed according to the terms of the **FreeBSD** License.
+
+See the COPYING.rdoc file for details.

data/Rakefile

@@ -1,13 +1,22 @@
+#!/usr/bin/env ruby
+
+require 'test/rake'
+
+Test::Rake::TestTask.new do |t|
+  t.libs  << 'test/fixtures'
+  t.tests << 'test/*.rb'
+end
+
 namespace :test do
 
-  desc 'run lemon unit tests'
+  desc 'run lemon unit tests (via shell command)'
   task :unit do
-    sh 'lemon -Itest/fixtures test/*.rb'
+    sh 'lemonade test -Itest/fixtures test/*.rb'
   end
 
   desc 'run qed demonstration tests'
   task :qed do
-    sh 'qed'
+    sh 'qed -Ilib spec/'
   end
 
 end

data/VERSION

@@ -1 +1 @@
-0.8.5
+0.9.0

data/bin/lemonade

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+# NOTE: This command would have been called `lemon` but there turns
+#       out to be a command by that name used by SQLite 2.x, so
+#       we have avoded the name clash by using `lemonade` instead.
+
+require 'lemon/cli'
+Lemon.cli(*ARGV)

data/lib/lemon.rb

@@ -16,5 +16,55 @@ module Lemon
 
 end
 
-require 'lemon/cli'
-require 'lemon/controller/coverage_analyzer'
+# Ruby Test standard location for test objects.
+$TEST_SUITE ||= []
+
+require 'lemon/test_class'
+
+module Lemon
+
+  # Lemon's toplevel test domain specific language.
+  module DSL
+
+    # Require script and record it.
+    #
+    # @param [STRING] script
+    #   The load path of a script.
+    #
+    def covers(script)
+      # TODO: record coverage list
+      require script
+    end
+    alias :Covers :covers
+
+    # Define a class/module test case.
+    #
+    # @param [Module,Class] target
+    #   The class or module the tests will target.
+    #
+    # @yield
+    #   Scope in which to define unit/method testcases.
+    #
+    def test_case(target, &block)
+      case target
+      when Class
+        $TEST_SUITE << Lemon::TestClass.new(:target=>target, &block)
+      when Module
+        $TEST_SUITE << Lemon::TestModule.new(:target=>target, &block)
+      else
+        if defined?(super)
+          super(target, &block)
+        else
+          raise
+        end
+      end
+    end
+
+    alias :TestCase :test_case
+    alias :testcase :test_case
+
+  end
+
+end
+
+extend Lemon::DSL