lemon 0.5

data/lib/lemon/test/concern.rb

@@ -0,0 +1,43 @@
+module Lemon::Test
+
+  # Test Concerns are used to organize unit tests
+  # in groups, so as to address specific quality
+  # assurance objectives.
+  class Concern
+
+    # The test case to which this concern belongs.
+    attr :testcase
+
+    # The description of this concern. Make this
+    # as detailed as you wish.
+    attr :description
+
+    # Unit tests that belong to this concern.
+    attr :testunits
+
+    # New concern.
+    def initialize(testcase, description)
+      @testcase    = testcase
+      @description = description.join("\n")
+      @testunits   = []
+    end
+
+    # Assign a unit test to this concern.
+    def assign(testunit)
+      raise ArgumentError unless Unit === testunit
+      @testunits << testunit
+    end
+
+    # Iterate through each test unit.
+    def each(&block)
+      @testunits.each(&block)
+    end
+
+    # Returns the description with newlines removed.
+    def to_s
+      description.gsub(/\n/, ' ')
+    end
+
+  end
+
+end

data/lib/lemon/test/suite.rb

@@ -0,0 +1,126 @@
+module Lemon
+module Test
+
+  require 'lemon/test/case'
+
+  # Test Suites encapsulate a set of test cases.
+  #
+  class Suite
+
+    # Test cases in this suite.
+    attr :testcases
+
+    # List of concern procedures that apply suite-wide.
+    attr :when_clauses
+
+    # List of pre-test procedures that apply suite-wide.
+    attr :before_clauses
+
+    # List of post-test procedures that apply suite-wide.
+    attr :after_clauses
+
+    # List of concern procedures that apply suite-wide.
+    attr :when_clauses
+
+    #
+    def initialize(*tests)
+      @testcases      = []
+      @before_clauses = {}
+      @after_clauses  = {}
+      @when_clauses   = {}
+
+      # directories glob *.rb files
+      tests = tests.flatten.map do |file|
+        if File.directory?(file)
+          Dir[File.join(file, '**', '*.rb')]
+        else
+          file
+        end
+      end.flatten.uniq
+
+      @test_files = tests
+
+      tests.each do |file|
+        #file = File.expand_path(file)
+        instance_eval(File.read(file), file)
+      end
+    end
+
+    # Load a helper. This method must be used when loading local
+    # suite support. The usual #require or #load can only be used
+    # for extenal support libraries (such as a test mock framework).
+    # This is so because suite code is not evaluated at the toplevel.
+    def helper(file)
+      instance_eval(File.read(file), file)
+    end
+
+    #
+    #def load(file)
+    #  instance_eval(File.read(file), file)
+    #end
+
+    # Includes at the suite level are routed to the toplevel.
+    def include(*mods)
+      TOPLEVEL_BINDING.eval('self').instance_eval do
+        include(*mods)
+      end
+    end
+
+    # Define a test case belonging to this suite.
+    def Case(target_class, &block)
+      testcases << Case.new(self, target_class, &block)
+    end
+
+    #
+    alias_method :TestCase, :Case
+
+    #
+    alias_method :testcase, :Case
+
+    # Define a pre-test procedure to apply suite-wide.
+    def Before(match=nil, &block)
+      @before_clauses[match] = block #<< Advice.new(match, &block)
+    end
+
+    alias_method :before, :Before
+
+    # Define a post-test procedure to apply suite-wide.
+    def After(match=nil, &block)
+      @after_clauses[match] = block #<< Advice.new(match, &block)
+    end
+
+    alias_method :after, :After
+
+    # Define a concern procedure to apply suite-wide.
+    def When(match=nil, &block)
+      @when_clauses[match] = block #<< Advice.new(match, &block)
+    end
+
+    # Iterate through this suite's test cases.
+    def each(&block)
+      @testcases.each(&block)
+    end
+
+    # 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.
+    # Becuase of closure, the constant lookup goes through here, and not
+    # the Case singleton class. So to work around wemust note each test
+    # before it is run, and reroute the missing constants.
+    #
+    # This sucks and it is not thread safe. If anyone know how to fix,
+    # please let me know. See Unit#call for the other end of this hack.
+
+    def self.const_missing(name)
+      (class << @@test_stack.last.testcase; self; end).const_get(name)
+    end
+
+    # Get current running test. Used for the BIG FAT HACK.
+    def test_stack
+      @@test_stack ||= []
+    end
+
+  end
+
+end
+end
+

data/lib/lemon/test/unit.rb

@@ -0,0 +1,56 @@
+module Lemon::Test
+
+  #
+  class Unit
+
+    # The test case to which this unit test belongs.
+    attr :testcase
+
+    # The concern which this test helps ensure.
+    attr :concern
+
+    # A test unit +target+ is a method.
+    attr :target
+
+    # The aspect of the concern this test fulfills.
+    attr :aspect
+
+    # Test procedure, in which test assertions should be made.
+    attr :procedure
+
+    # New unit test.
+    def initialize(concern, target, aspect=nil, &procedure)
+      concern.assign(self)
+
+      @concern   = concern
+      @testcase  = concern.testcase
+
+      @target    = target
+      @aspect    = aspect
+      @procedure = procedure
+    end
+
+    # This method has the other end of the BIG FAT HACK. See Suite#const_missing.
+    def call
+      suite.test_stack << self  # hack
+      procedure.call
+    ensure
+      suite.test_stack.pop
+    end
+
+    # The suite to which this unit test belongs.
+    def suite
+      testcase.suite
+    end
+
+    #
+    def to_s
+      "#{testcase}##{target} #{aspect}"
+    end
+
+  end
+
+end
+
+
+

data/meta/author

@@ -0,0 +1 @@
+Thomas Sawyer

data/meta/contact

@@ -0,0 +1 @@
+proutils@librelist.com

data/meta/copyright

@@ -0,0 +1 @@
+Copyright 2009 Thomas Sawyer

data/meta/description

@@ -0,0 +1,2 @@
+Lemon is a unit testing framework that tightly correlates
+class to test case and method to test unit.

data/meta/homepage

@@ -0,0 +1 @@
+http://proutils.github.com/lemon

data/meta/license

@@ -0,0 +1 @@
+LGPL

data/meta/name

@@ -0,0 +1 @@
+lemon

data/meta/repository

@@ -0,0 +1 @@
+git://github.com/proutils/lemon.git

data/meta/suite

@@ -0,0 +1 @@
+proutils 

data/meta/summary

@@ -0,0 +1 @@
+Pucker-tight Unit Testing

data/meta/title

@@ -0,0 +1 @@
+Lemon

data/meta/version

@@ -0,0 +1 @@
+0.5

data/test/cases/coverage_case.rb

@@ -0,0 +1,26 @@
+#
+
+testcase Lemon::Coverage do
+
+  #Before /returns/ do |unit|
+  #  puts "returns something"
+  #end
+
+  unit :coverage => 'returns a chart of coverage' do
+    #X.new.a.assert.is_a?(String)
+  end
+
+  unit :cover => 'returns a pre-checked chart of potential coverage' do
+    #X.new.a.assert =~ /^[a-z]*$/
+  end
+
+  unit :system => 'returns a list of classes/modules currently in the Ruby proccess' do
+    #1.assert == 4
+  end
+
+  #unit :snapshot => 'can be broken' do
+  #  #1.assert == 4
+  #end
+
+end
+

data/test/cases/testcase_case.rb

@@ -0,0 +1,58 @@
+# Some fixture code for testing #include.
+module M
+  def m1; "m1"; end
+  module N
+    def self.n1; "n1"; end
+  end
+end
+
+Case(Lemon::Test::Case) do
+
+  Concern "Modules included in a test case are accessible by the unit tests."
+
+  include M
+  #N = M::N
+
+  Unit :include => "allows access to module methods" do
+    m1.assert == "m1"
+  end
+
+  Unit :include => "allows access to nested modules" do
+    N::n1.assert == "n1"
+  end
+
+
+  Concern "Unit tests are augmented by before and after procedures."
+
+  Before /pre-test/ do |unit|
+    @check_before = :before
+  end
+
+  After /pre-test/ do |unit|
+    @check_after = :after
+  end
+
+  Unit :Before => "sets up a pre-test procedure" do
+    @check_before.assert == :before
+  end
+
+  Unit :After => "sets up a post-test procedure" do
+    @check_after.assert == :after
+  end
+
+
+  #Concern "Unit tests are augmented by when procedures.",
+  #        "(NOTE: we have to repeat this concern in order to test it.)"
+
+  When /augmented\ by\ when\ procedures/ do
+    @check_concern = :concern
+  end
+
+  Concern "Unit tests are augmented by when procedures."
+
+  Unit :Concern => "sets up a concern procedure" do
+    @check_concern.assert == :concern
+  end
+
+end
+

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification 
+name: lemon
+version: !ruby/object:Gem::Version 
+  version: "0.5"
+platform: ruby
+authors: 
+- Thomas Sawyer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-31 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: |-
+  Lemon is a unit testing framework that tightly correlates
+  class to test case and method to test unit.
+email: proutils@librelist.com
+executables: 
+- lemon
+extensions: []
+
+extra_rdoc_files: 
+- MANIFEST
+- README.rdoc
+- HISTORY
+- COPYING.LESSER
+- Syckfile
+- COPYING
+files: 
+- COPYING
+- COPYING.LESSER
+- HISTORY
+- README.rdoc
+- bin/lemon
+- lib/lemon.rb
+- lib/lemon/command.rb
+- lib/lemon/coverage.rb
+- lib/lemon/kernel.rb
+- lib/lemon/reporter.rb
+- lib/lemon/reporters.rb
+- lib/lemon/reporters/dotprogress.rb
+- lib/lemon/reporters/verbose.rb
+- lib/lemon/runner.rb
+- lib/lemon/test/case.rb
+- lib/lemon/test/concern.rb
+- lib/lemon/test/suite.rb
+- lib/lemon/test/unit.rb
+- meta/author
+- meta/contact
+- meta/copyright
+- meta/description
+- meta/homepage
+- meta/license
+- meta/name
+- meta/repository
+- meta/suite
+- meta/summary
+- meta/title
+- meta/version
+- test/cases/coverage_case.rb
+- test/cases/testcase_case.rb
+- MANIFEST
+- Syckfile
+has_rdoc: true
+homepage: http://proutils.github.com/lemon
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --title
+- Lemon API
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: lemon
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Pucker-tight Unit Testing
+test_files: 
+- test/cases/testcase_case.rb