lemon 0.8.5 → 0.9.0

data/lib/lemon/test_module.rb

@@ -0,0 +1,114 @@
+module Lemon
+
+  require 'lemon/test_case'
+  require 'lemon/test_method'
+
+  # The nomenclature of a TestModule limts the focus of testing
+  # the methods of a module.
+  #
+  class TestModule < TestCase
+
+    # New unit test.
+    def initialize(settings={}, &block)
+      @tested = false
+      super(settings)
+    end
+
+    # Make sure the target is a module.
+    def validate_settings
+      raise "#{@target} is not a module" unless Module === @target
+    end
+
+    # The type of test case.
+    def type
+      'Module'
+    end    
+
+    # Gives the name of the target module.
+    def to_s
+      target.to_s
+    end
+
+    # Evaluation scope for TestModule.
+    class Scope < TestCase::Scope
+
+      # Define a method/unit subcase for the class/module testcase.
+      #
+      # @example
+      #   unit :puts do
+      #     test "print message with new line to stdout" do
+      #       puts "Hello"
+      #     end
+      #   end
+      #
+      def unit(method, &block)
+        meth = TestMethod.new(
+          :context  => @_testcase, 
+          :setup    => @_setup,
+          :skip     => @_skip,
+          :target   => method.to_sym,
+          :function => false,
+          &block
+        )
+        @_testcase.tests << meth
+        meth
+      end
+      alias :Unit :unit
+
+      # More specific nomencalture for `#unit`.
+      alias :method :unit
+      alias :Method :unit
+
+      # Define a class-method unit test for this case.
+      #
+      def class_unit(method, &block)
+        meth = TestMethod.new(
+          :context  => @_testcase,
+          :setup    => @_setup,
+          :skip     => @_skip,
+          :target   => method.to_sym,
+          :function => true,
+          &block
+        )
+        @_testcase.tests << meth
+        meth
+      end
+      alias :ClassUnit :class_unit
+
+      # More specific nomencalture for `#class_unit`.
+      alias :class_method :class_unit
+      alias :ClassMethod  :class_unit
+
+      # Alternate nomenclature for class_unit.
+      alias :Function :ClassMethod
+      alias :function :ClassMethod
+
+      #--
+      # TODO: Allow sub-cases?
+      #++
+
+      # Create a subcase of module testcase.
+      def context(label, &block)
+        @_testcase.tests << TestModule.new(
+          :context => @_testcase,
+          :target  => @_testcase.target,
+          :setup   => @_setup,
+          :skip    => @_skip,
+          :label   => label,
+          &block
+        )
+      end
+      alias :Context :context
+
+      #
+      def skip(reason=true, &block)
+        @_skip = reason
+        block.call
+        @_skip = nil
+      end
+
+    end
+
+  end
+
+end

data/lib/lemon/test_proc.rb

@@ -0,0 +1,140 @@
+module Lemon
+
+  # Test procedure.
+  #
+  class TestProc
+
+    # New test procedure.
+    #
+    def initialize(settings={}, &procedure)
+      @context = settings[:context]
+      @setup   = settings[:setup]
+      @label   = settings[:label]
+      @skip    = settings[:skip]
+
+      @procedure = procedure
+
+      @tested    = false
+    end
+
+  public
+
+    # The parent case to which this test belongs.
+    attr :context
+
+    # Setup and teardown procedures.
+    attr :setup
+
+    # Description of test.
+    attr :label
+
+    # Test procedure, in which test assertions should be made.
+    attr :procedure
+
+    #
+    #attr :caller
+
+    # Target method of context.
+    def target
+      context.target
+    end
+
+    #
+    attr_accessor :skip
+
+    # Don't run test?
+    def skip?
+      @skip
+    end
+
+    # Has this test been executed?
+    attr_accessor :tested
+
+    # Test label.
+    def to_s
+      label.to_s
+    end
+
+    alias_method :name, :to_s
+
+    # Ruby Test looks for #topic as the description of test setup.
+    def topic
+      setup.to_s
+    end
+
+    #
+    #def description
+    #  if function?
+    #    #"#{test_case} .#{target} #{aspect}"
+    #    "#{test_case}.#{target} #{context} #{aspect}".strip
+    #  else
+    #    a  = /^[aeiou]/i =~ test_case.to_s ? 'An' : 'A'
+    #    #"#{a} #{test_case} receiving ##{target} #{aspect}"
+    #    "#{test_case}##{target} #{context} #{aspect}".strip
+    #  end
+    #end
+
+    #
+    #def name
+    #  if function?
+    #    "#{test_case}.#{target}"
+    #  else
+    #    "#{test_case}##{target}"
+    #  end
+    #end
+
+    # TODO: handle parameterized tests
+    def arguments
+      []
+    end
+
+    #
+    def to_proc
+      lambda do
+        call
+      end
+    end
+
+    #
+    def match?(match)    
+      match == target || match === description
+    end
+
+    #
+    def call
+      context.run(self) do
+        setup.run_setup(scope)    if setup
+        scope.instance_exec(*arguments, &procedure)
+        setup.run_teardown(scope) if setup
+      end
+    end
+
+    #
+    def scope
+      context.scope
+    end
+
+=begin
+    # The file_and_line method returns the file name and line number of
+    # the caller created upon initialization of this object.
+    #
+    # This method is cached.
+    #
+    # Examples
+    #   file_and_line #=> ['foo_test.rb', 123]
+    #
+    # Returns Array of file name and line number of caller.
+    def source_location
+      @file_and_line ||= (
+        line = caller[0]
+        i = line.rindex(':in')
+        line = i ? line[0...i] : line
+        f, l = File.basename(line).split(':')
+        [f, l]
+      )
+    end
+=end
+
+  end
+
+end

data/lib/lemon/test_setup.rb

@@ -0,0 +1,54 @@
+module Lemon
+
+  # Test Subject - Setup and Teardown code.
+  class TestSetup
+
+    # The test case to which this advice belong.
+    attr :context
+
+    # The description of this concern. Make this
+    # as detailed as you wish.
+    attr :description
+
+    # Setup procedure.
+    attr :setup
+
+    # Teardown procedure.
+    attr :teardown
+
+    # New case instance.
+    def initialize(context, description, options={}, &setup)
+      @context      = context
+      @description  = description.to_s
+      #@function    = options[:function] || options[:singleton]
+      #@type        = options[:type] || :context
+      @setup        = [setup].flatten
+      @teardown     = []
+    end
+
+    #
+    def teardown=(procedure)
+       @teardown = [procedure]
+    end
+
+    # Setup.
+    def run_setup(scope)
+      setup.each do |proc|
+        scope.instance_eval(&proc)
+      end
+    end
+
+    # Teardown.
+    def run_teardown(scope)
+      teardown.each do |proc|
+        scope.instance_eval(&proc)
+      end
+    end
+
+    # Returns the description with newlines removed.
+    def to_s
+      description.gsub(/\n/, ' ')
+    end
+  end
+
+end

data/lib/lemon/test_world.rb

@@ -0,0 +1,9 @@
+module Lemon
+
+  # The World module is the base class for all Lemon test scopes.
+  # To add test specific helper methods for your tests, place them here.
+  #
+  class World < Module
+  end
+
+end

data/notes/2011-07-07-nailing-down-the-nomenclature.md

@@ -0,0 +1,6 @@
+# 2011-07-07 | Nailing Down the Nomenclature
+
+I have finally settled on `test_class` and `test_module` as thew new toplevel method for defining Lemon test cases. I decided against reusing `test_case` from Citron b/c I determined it is best that these types of test cases not be mixed together, but rather stay cleanly separated.
+
+I also decided against the original KO inspired nomenclature of `Test.case`. Though it looks very cool at first glance, in the end it goes against the grain. For instance, would one design an RSpec-stlye nomenclature as `Test.describe`, or a Cucumber-style nomenclature using `Test.feature`? While one could do so, it's completely uneccessry.
+

data/site/index.html

@@ -66,12 +66,13 @@
   TestCase HelloWorld do
     Concern "String output works as expected."
 
-    Unit :to_s => "returns a string" do
-      HelloWorld.new.to_s.assert.is_a?(String)
-    end
-
-    Unit :to_s => "returns the world famous phrase" do
-      HelloWorld.new.to_s.assert == "Hello, World!"
+    Unit :to_s do
+      Test "returns a string" do
+        HelloWorld.new.to_s.assert.is_a?(String)
+      end
+      Test "returns the world famous phrase" do
+        HelloWorld.new.to_s.assert == "Hello, World!"
+      end
     end
   end
   </pre>

data/{qed → spec}/coverage/01_complete.rdoc

@@ -20,19 +20,23 @@ Given an example script in 'lib/complete_example.rb' as follows:
 
 And given a test case in 'test/complete_example_case.rb' as follows:
 
-    covers 'complete_example.rb'
+    Covers 'complete_example.rb'
 
-    testcase C1 do
-      unit :f1 => "Returns a String" do
+    TestCase C1 do
+      method :f1 do 
+        test "Returns a String"
       end
-      unit :f2 => "Returns a String" do
+      method :f2 do
+        test "Returns a String"
       end
-      unit :f3 => "Returns a String" do
+      method :f3 do
+        test "Returns a String"
       end
     end
 
-    testcase C2 do
-      unit :g1 => "Returns a String" do
+    TestCase C2 do
+      method :g1 do
+        test "Returns a String"
       end
     end
 
@@ -78,23 +82,29 @@ 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 'test/complete_example_case.rb' as follows:
 
-    covers 'complete_example.rb'
+    Covers 'complete_example.rb'
 
-    testcase C1 do
-      unit :f1 => "Returns a String" do
+    TestCase C1 do
+      method :f1 do
+        test "Returns a String"
       end
-      unit :f2 => "Returns a String" do
+      method :f2 do
+        test "Returns a String"
       end
-      unit :f3 => "Returns a String" do
+      method :f3 do
+        test "Returns a String"
       end
     end
 
-    testcase C2 do
-      unit :g1 => "Returns a String" do
+    TestCase C2 do
+      method :g1 do
+        test "Returns a String"
       end
-      unit :g2 => "Returns a String" do
+      method :g2 do
+        test "Returns a String"
       end
-      unit :g3 => "Returns a String" do
+      method :g3 do
+        test "Returns a String"
       end
     end
 

data/{qed → spec}/coverage/02_incomplete.rdoc

@@ -24,17 +24,20 @@ Given an example script in 'lib/incomplete_example.rb' as follows:
 
 And given a test case in 'test/incomplete_example_case.rb' as follows:
 
-    covers 'incomplete_example.rb'
+    Covers 'incomplete_example.rb'
 
-    testcase I1 do
-      unit :f1 => "Returns a String" do
+    TestCase I1 do
+      method :f1 do
+        test "Returns a String"
       end
-      unit :f2 => "Returns a String" do
+      method :f2 do
+        test "Returns a String"
       end
     end
 
-    testcase I2 do
-      unit :x1 => "Does not exist" do
+    TestCase I2 do
+      method :x1 do
+        test "Does not exist"
       end
     end
 
@@ -68,7 +71,7 @@ But I3 will be listed in the uncovered cases list.
     coverage.uncovered_cases == [I3]
 
 Note that uncovered case methods can be included in the uncovered units list
-by setting the +zealous+ option, which we will demonstrate later.
+by setting the +zealous+ option, which we will demonstrated later.
 
 There should still be 3 covered units, I1#f1, I1#f2 and I2#x1.