lemon 0.9.0 → 0.9.2

data/lib/lemon/test_case.rb

@@ -2,6 +2,7 @@ require 'lemon/core_ext'
 require 'lemon/test_advice'
 require 'lemon/test_setup'
 require 'lemon/test_world'
+require 'lemon/test_scope'
 
 module Lemon
 
@@ -32,6 +33,7 @@ module Lemon
     # Skip execution of test case?
     attr :skip
 
+    #
     # A test case +target+ is a class or module.
     #
     # @param [Hash] settings
@@ -59,58 +61,88 @@ module Lemon
       @label   = settings[:label]
       @setup   = settings[:setup]
       @skip    = settings[:skip]
+      @tags    = settings[:tags]
 
       @advice  = @context ? @context.advice.dup : TestAdvice.new
 
       @tests   = []
-      @scope   = scope_class.new(self)
+      @domain  = domain_class.new(self)
 
       validate_settings
 
       evaluate(&block)
     end
 
+    #
     # Subclasses can override this methof to validate settings. 
     # It is run just before evaluation of scope block.
+    #
     def validate_settings
     end
 
+    # 
+    def domain
+      @domain
+    end
+
+    #
+    #
     #
     def evaluate(&block)
-      @scope.module_eval(&block)
+      @domain.module_eval(&block)
     end
 
+    #
     # Iterate over each test and subcase.
+    #
     def each(&block)
       tests.each(&block)
     end
 
+    #
     # Number of tests and subcases.
+    #
     def size
       tests.size
     end
 
+    #
     # Subclasses of TestCase can override this to describe
     # the type of test case they define.
+    #
     def type
-      'Case'
+      'Test Case'
     end
 
+    #
+    #
     #
     def to_s
       @label.to_s
     end
 
+    #
+    #
     #
     def skip?
       @skip
     end
 
+    #
+    #
     #
     def skip!(reason=true)
       @skip = reason
     end
 
+    #
+    #
+    #
+    def tags
+      @tags
+    end
+
+    #
     # Run test in the context of this case.
     #
     # @param [TestProc] test
@@ -132,48 +164,47 @@ module Lemon
       end
     end
 
+    #
     # Module for evaluating test case script.
     #
     # @return [Scope] evaluation scope
+    #
     def scope
-      @scope
+      @scope ||= TestScope.new(self)
     end
 
-    # Get the scope class dynamically so that each subclass
+    #
+    # Get the domain class dynamically so that each subclass
     # of TestCase will retrieve it's own.
-    def scope_class
-      self.class.const_get(:Scope)
+    #
+    def domain_class
+      self.class.const_get(:DSL)
     end
 
     #
-    class Scope < World
+    class DSL < World
+
+      #
+      # The class for which this is a DSL context.
+      #
+      def context_class
+        TestCase
+      end
 
+      #
+      #
       #
       def initialize(testcase) #, &code)
         @_testcase = testcase
         @_setup    = testcase.setup
         @_skip     = nil
 
-        extend testcase.context.scope if testcase.context
+        include testcase.context.domain if testcase.context
 
         #module_eval(&code)
       end
 
-      #--
-      # THINK: Instead of resuing TestCase can we have a TestContext
-      #        or other way to more generically mimics the parent context?
-      #++
-
-      ##
-      #def context(label, &block)
-      #  @_testcase.tests << TestCase.new(
-      #    :testcase => @testcase,
-      #    :label    => label,
-      #    &block
-      #  )
-      #end
-      #alias :Context :context
-
+      #
       # Setup is used to set things up for each unit test.
       # The setup procedure is run before each unit.
       #
@@ -187,10 +218,13 @@ module Lemon
       end
       alias :Setup :setup
 
+      #
       # Original Lemon nomenclature for `#setup`.
+      #
       alias :concern :setup
       alias :Concern :setup
 
+      #
       # Teardown procedure is used to clean-up after each unit test.
       #
       def teardown(&procedure)
@@ -198,11 +232,10 @@ module Lemon
       end
       alias :Teardown :teardown
 
-      #--
       # TODO: Allow Before and After to handle setup and teardown?
       #       But that would only allow one setup per case.
-      #++
 
+      #
       # Define a _complex_ before procedure. The #before method allows
       # before procedures to be defined that are triggered by a match
       # against the unit's target method name or _aspect_ description.
@@ -233,6 +266,7 @@ module Lemon
       end
       alias :Before :before
 
+      #
       # Define a _complex_ after procedure. The #before method allows
       # before procedures to be defined that are triggered by a match
       # against the unit's target method name or _aspect_ description.
@@ -263,6 +297,81 @@ module Lemon
       end
       alias :After :after
 
+      # THINK: Instead of resuing TestCase can we have a TestContext
+      #        or other way to more generically mimics the parent context?
+
+      #
+      # Create a subcase of module testcase.
+      #
+      def context(label, *tags, &block)
+        return if @_omit
+
+        @_testcase.tests << context_class.new(
+          :context => @_testcase,
+          :target  => @_testcase.target,
+          :setup   => @_setup,
+          :skip    => @_skip,
+          :label   => label,
+          :tags    => tags,
+          &block
+        )
+      end
+      alias :Context :context
+
+      #
+      # Skip tests. Unlike omit, skipped tests are passed to the test harness,
+      # so they still can be included in reports, though they are not executed.
+      #
+      # If a block is given then only tests defined with-in the block are skipped.
+      # If no block is given then all subsquent tests in the test case are skipped.
+      #
+      # @param [String,Boolean] reason
+      #   A description of the reason to skip the test, or simply a boolean value.
+      #
+      # @example
+      #   skip "reason" do
+      #     test do
+      #       ...
+      #     end
+      #   end
+      #
+      def skip(reason=true)
+        if block_given?
+          @_skip = reason
+          yield
+          @_skip = nil
+        else
+          @_skip = reason
+        end
+      end
+      alias :Skip :skip
+
+      #
+      # Omitted tests are simply ignored and never instantiated let alone passed
+      # on to the test harness.
+      #
+      # If a block is given then only tests defined with-in the block are skipped.
+      # If no block is given then all subsquent tests in the test case are skipped.
+      #
+      #
+      # @example
+      #   omit do
+      #     test do
+      #       ...
+      #     end
+      #   end
+      #
+      def omit(reason=true)
+        if block_given?
+          @_omit = reason
+          yield
+          @_omit = nil
+        else
+          @_omit = reason
+        end
+      end
+      alias :Omit :omit
+
     end
 
   end

data/lib/lemon/test_class.rb

@@ -9,18 +9,31 @@ module Lemon
 
     private
 
+    #
     # Make sure the target is a class.
-    def validate_target
-      raise unless Class === @target
+    #
+    def validate_settings
+      raise "#{@target} is not a module" unless Class === @target
     end
 
+    #
     # The type of testcase.
+    #
     def type
       'Class'
     end    
 
     # Evaluation scope for {TestClass}.
-    class Scope < TestModule::Scope
+    #
+    class DSL < TestModule::DSL
+
+      #
+      # The class for which this is a DSL context.
+      #
+      def context_class
+        TestClass
+      end
+
     end
 
   end

data/lib/lemon/test_class_method.rb

@@ -0,0 +1,58 @@
+module Lemon
+
+  require 'lemon/test_method'
+
+  # Subclass of TestMethod used for class methods.
+  # It's basically the same class.
+  #
+  class TestClassMethod < TestMethod
+
+    # Description of the type of test case.
+    def type
+      'Class Method'
+    end
+
+    # If class method, returns target method's name prefixed with double colons.
+    # If instance method, then returns target method's name prefixed with hash
+    # character.
+    def name
+      "::#{target}"
+    end
+
+    # Returns the prefixed method name.
+    def to_s
+      "::#{target}"
+    end
+
+    # Returns the fully qulaified name of the target method. This is
+    # the standard interface used by RubyTest.
+    def unit
+      "#{context}.#{target}"
+    end
+
+    # For a class method, the target class is the meta-class.
+    def target_class
+      @target_class ||= (class << context.target; self; end)
+    end
+
+    #
+    def class_method?
+      true
+    end
+
+    # Scope for evaluating class method test definitions.
+    #
+    class DSL < TestMethod::DSL
+
+      #
+      # The class for which this is a DSL context.
+      #
+      def context_class
+        TestClassMethod
+      end
+
+    end
+
+  end
+
+end

data/lib/lemon/test_method.rb

@@ -8,64 +8,62 @@ module Lemon
   #
   class TestMethod < TestCase
 
-    # New unit test.
     #
-    # @option settings [Boolean] :function
-    #   Is the target method a class method, or not.
+    # New unit test.
     #
     def initialize(settings={}, &block)
       @tested   = false
-      @function = settings[:function]
       super(settings)
     end
 
+    #
     # Validate that a context and target method have been supplied.
+    #
     def validate_settings
       raise "method test has no module or class context" unless @context
       raise "#{@target} is not a method name" unless Symbol === @target
     end
 
-    # Type is either `Method` or `Function` (a function is a class method).
+    #
+    # Description of the type of test case.
+    #
     def type
-      if function?
-        'Function'
-      else
-        'Method'
-      end
+      'Method'
     end
 
+    #
     # Used to make sure the the method has been tested, or not.
+    #
     attr_accessor :tested
 
-    # Is this method a class method?
-    def function?
-      @function
-    end
-
-    # A function is also known as a "class method".
-    alias :class_method? :function?
-
+    #
     # If class method, returns target method's name prefixed with double colons.
     # If instance method, then returns target method's name prefixed with hash
     # character.
+    #
     def name
-      function? ? "::#{target}" : "##{target}"
+      "##{target}"
     end
 
     # TODO: If sub-cases are to be supported than we need to incorporate
     #       the label into to_s.
 
+    #
     # Returns the prefixed method name.
+    #
     def to_s
-      function? ? "::#{target}" : "##{target}"
+      "##{target}"
     end
 
+    #
     # Returns the fully qulaified name of the target method. This is
     # the standard interface used by Ruby Test.
+    #
     def unit
-      function? ? "#{context}.#{target}" : "#{context}##{target}"
+      "#{context}##{target}"
     end
 
+    #
     # Run test in the context of this case. Notice that #run for
     # TestMethod is more complex than a general TestCase. This is
     # to ensure that the target method is invoked during the course
@@ -109,6 +107,8 @@ module Lemon
       raise_pending(test.procedure) unless test.tested
     end
 
+    #
+    #
     #
     def raise_pending(procedure)
       if RUBY_VERSION < '1.9'
@@ -118,22 +118,32 @@ module Lemon
       end
     end
 
-    # If the target method is a class method, then the target class is the
-    # meta-class, otherwise just the class itself.
+    #
+    # The target class.
+    #
     def target_class
-      @target_class ||= (
-        if function? 
-          (class << context.target; self; end)
-        else
-          context.target
-        end
-      )
+      @target_class ||= context.target
+    end
+
+    #
+    #
+    #
+    def class_method?
+      false
     end
 
     # Scope for evaluating method test definitions.
     #
-    class Scope < TestCase::Scope
+    class DSL < TestCase::DSL
 
+      #
+      # The class for which this is a DSL context.
+      #
+      def context_class
+        TestMethod
+      end
+
+      #
       # Define a unit test for this case.
       #
       # @example
@@ -141,64 +151,43 @@ module Lemon
       #     puts "Hello"
       #   end
       #
-      def test(label=nil, &block)
-        block = Omission.new(@_omit).to_proc if @_omit
+      def test(label=nil, *tags, &block)
+        return if @_omit
+
         test  = TestProc.new(
           :context => @_testcase,
           :setup   => @_setup,
           :skip    => @_skip,
           :label   => label,
+          :tags    => tags,
           &block
         )
+
         @_testcase.tests << test
+
         test
       end
-      alias :Test :test
 
-      # Create a sub-case ofr the method case.
-      def context(label, &block)
+      #
+      # Create a sub-case of the method case.
+      #
+      def context(label, *tags, &block)
+        return if @_omit
+
         @_testcase.tests << TestMethod.new(
           :context => @_testcase,
           :target  => @_testcase.target,
           :setup   => @_setup,
           :skip    => @_skip,
           :label   => label,
+          :tags    => tags,
           &block
         )
       end
-      alias :Context :context
-
-      # Omit tests.
-      #
-      # @example
-      #   omit "reason" do
-      #     test do
-      #       ...
-      #     end
-      #   end
-      #
-      def omit(label=true, &block)
-        @_omit = label
-        block.call
-        @_omit = nil
-      end
-      alias :Omit :omit
 
-      # Skip tests. Unlike omit, skipped tests are not executed at all.
-      #
-      # @example
-      #   skip "reason" do
-      #     test do
-      #       ...
-      #     end
-      #   end
-      #
-      def skip(label=true, &block)
-        @_skip = label
-        block.call
-        @_skip = nil
-      end
-      alias :Skip :skip
+      # Capitialized term.
+      alias :Test :test
+      alias :Context :context
 
     end