lemon 0.8.5 → 0.9.0

data/lib/lemon/test_advice.rb

@@ -0,0 +1,63 @@
+module Lemon
+
+  #--
+  # TODO: Probably can replace advice with simple hash.
+  #++
+
+  # Test Advice
+  class TestAdvice
+
+    # The test case to which this advice belongs.
+    #attr :context
+
+    #
+    attr :table
+
+    # New case instance.
+    def initialize
+      @table = Hash.new{ |h,k| h[k] = {} }
+    end
+
+    #
+    def initialize_copy(original)
+      @table = original.table.clone
+    end
+
+    #
+    def [](type)
+      @table[type.to_sym]
+    end
+
+=begin
+    #
+    #def teardown=(procedure)
+    #   @teardown = procedure
+    #end
+
+    # Setup.
+    def setup(scope=nil)
+      if scope
+        scope.instance_eval(&@setup)
+      else
+        @setup
+      end
+    end
+
+    # Teardown.
+    def teardown(scope=nil)
+      if scope
+        scope.instance_eval(&@teardown) if @teardown
+      else
+        @teardown
+      end
+    end
+
+    # Returns the description with newlines removed.
+    def to_s
+      description.gsub(/\n/, ' ')
+    end
+=end
+
+  end
+
+end

data/lib/lemon/test_case.rb

@@ -0,0 +1,270 @@
+require 'lemon/core_ext'
+require 'lemon/test_advice'
+require 'lemon/test_setup'
+require 'lemon/test_world'
+
+module Lemon
+
+  # Test Case serves as the base class for Lemon's
+  # specialized test case classes.
+  #
+  class TestCase
+
+    # The parent context in which this case resides.
+    attr :context
+
+    # Brief description of the test case.
+    attr :label
+
+    # Target component.
+    attr :target
+
+    # The setup and teardown advice.
+    attr :setup
+
+    # Advice are labeled procedures, such as before
+    # and after advice.
+    attr :advice
+
+    # List of tests and sub-contexts.
+    attr :tests
+
+    # Skip execution of test case?
+    attr :skip
+
+    # A test case +target+ is a class or module.
+    #
+    # @param [Hash] settings
+    #   The settings used to define the test case.
+    #
+    # @option settings [TestCase] :context
+    #   Parent test case.
+    #
+    # @option settings [Module,Class,Symbol] :target
+    #   The testcase's target.
+    #
+    # @option settings [String] :label
+    #   Breif description of testcase.
+    #   (NOTE: this might not be used)
+    #
+    # @option settings [TestSetup] :setup
+    #   Test setup.
+    #
+    # @option settings [Boolean] :skip
+    #   If runner should skip test.
+    #
+    def initialize(settings={}, &block)
+      @context = settings[:context]
+      @target  = settings[:target]
+      @label   = settings[:label]
+      @setup   = settings[:setup]
+      @skip    = settings[:skip]
+
+      @advice  = @context ? @context.advice.dup : TestAdvice.new
+
+      @tests   = []
+      @scope   = scope_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 evaluate(&block)
+      @scope.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'
+    end
+
+    #
+    def to_s
+      @label.to_s
+    end
+
+    #
+    def skip?
+      @skip
+    end
+
+    #
+    def skip!(reason=true)
+      @skip = reason
+    end
+
+    # Run test in the context of this case.
+    #
+    # @param [TestProc] test
+    #   The test unit to run.
+    #
+    def run(test, &block)
+      advice[:before].each do |matches, block|
+        if matches.all?{ |match| test.match?(match) }
+          scope.instance_exec(test, &block) #block.call(unit)
+        end
+      end
+
+      block.call
+
+      advice[:after].each do |matches, block|
+        if matches.all?{ |match| test.match?(match) }
+          scope.instance_exec(test, &block) #block.call(unit)
+        end
+      end
+    end
+
+    # Module for evaluating test case script.
+    #
+    # @return [Scope] evaluation scope
+    def scope
+      @scope
+    end
+
+    # Get the scope class dynamically so that each subclass
+    # of TestCase will retrieve it's own.
+    def scope_class
+      self.class.const_get(:Scope)
+    end
+
+    #
+    class Scope < World
+
+      #
+      def initialize(testcase) #, &code)
+        @_testcase = testcase
+        @_setup    = testcase.setup
+        @_skip     = nil
+
+        extend testcase.context.scope 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.
+      #
+      # @param [String] description
+      #   A brief description of what the setup procedure sets-up.
+      #
+      def setup(description=nil, &procedure)
+        if procedure
+          @_setup = TestSetup.new(@test_case, description, &procedure)
+        end
+      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)
+        @_setup.teardown = procedure
+      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.
+      # This allows groups of tests to be defined that share special
+      # setup code.
+      #
+      # @example
+      #   Method :puts do
+      #     Test "standard output (@stdout)" do
+      #       puts "Hello"
+      #     end
+      #
+      #     Before /@stdout/ do
+      #       $stdout = StringIO.new
+      #     end
+      #
+      #     After /@stdout/ do
+      #       $stdout = STDOUT
+      #     end
+      #   end
+      #
+      # @param [Array<Symbol,Regexp>] matches
+      #   List of match critera that must _all_ be matched
+      #   to trigger the before procedure.
+      #
+      def before(*matches, &procedure)
+        @_testcase.advice[:before][matches] = procedure
+      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.
+      # This allows groups of tests to be defined that share special
+      # teardown code.
+      #
+      # @example
+      #   Method :puts do
+      #     Test "standard output (@stdout)" do
+      #       puts "Hello"
+      #     end
+      #
+      #     Before /@stdout/ do
+      #       $stdout = StringIO.new
+      #     end
+      #
+      #     After /@stdout/ do
+      #       $stdout = STDOUT
+      #     end
+      #   end
+      #
+      # @param [Array<Symbol,Regexp>] matches
+      #   List of match critera that must _all_ be matched
+      #   to trigger the after procedure.
+      #
+      def after(*matches, &procedure)
+        @_testcase.advice[:after][matches] = procedure
+      end
+      alias :After :after
+
+    end
+
+  end
+
+end

data/lib/lemon/test_class.rb

@@ -0,0 +1,28 @@
+module Lemon
+
+  require 'lemon/test_module'
+
+  # Subclass of TestModule used for classes.
+  # It's basically the same class.
+  #
+  class TestClass < TestModule
+
+    private
+
+    # Make sure the target is a class.
+    def validate_target
+      raise unless Class === @target
+    end
+
+    # The type of testcase.
+    def type
+      'Class'
+    end    
+
+    # Evaluation scope for {TestClass}.
+    class Scope < TestModule::Scope
+    end
+
+  end
+
+end

data/lib/lemon/test_method.rb

@@ -0,0 +1,207 @@
+module Lemon
+
+  require 'lemon/test_case'
+  require 'lemon/test_proc'
+
+  # The TestMethod class is a special TestCase that requires
+  # a particular target method be tested.
+  #
+  class TestMethod < TestCase
+
+    # New unit test.
+    #
+    # @option settings [Boolean] :function
+    #   Is the target method a class method, or not.
+    #
+    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).
+    def type
+      if function?
+        'Function'
+      else
+        'Method'
+      end
+    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}"
+    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}"
+    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}"
+    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
+    # of the test.
+    #
+    # @param [TestProc] test
+    #   The test procedure instance to run.
+    #
+    # @yield
+    #   The procedure for running the test.
+    #
+    def run(test, &block)
+      target = self.target
+
+      raise_pending(test.procedure) unless test.procedure
+
+      begin
+        target_class.class_eval do
+          alias_method "_lemon_#{target}", target
+          define_method(target) do |*a,&b|
+            test.tested = true
+            __send__("_lemon_#{target}",*a,&b)
+          end
+        end
+      rescue => error
+        Kernel.eval <<-END, test.to_proc.binding
+          raise #{error.class}, "#{target} not tested"
+        END
+      end
+
+      begin
+        super(test, &block)
+        #block.call
+
+      ensure
+        target_class.class_eval %{
+          alias_method "#{target}", "_lemon_#{target}"
+        }
+      end
+
+      raise_pending(test.procedure) unless test.tested
+    end
+
+    #
+    def raise_pending(procedure)
+      if RUBY_VERSION < '1.9'
+        Kernel.eval %[raise NotImplementedError, "#{target} not tested"], procedure
+      else
+        Kernel.eval %[raise NotImplementedError, "#{target} not tested"], procedure.binding
+      end
+    end
+
+    # If the target method is a class method, then the target class is the
+    # meta-class, otherwise just the class itself.
+    def target_class
+      @target_class ||= (
+        if function? 
+          (class << context.target; self; end)
+        else
+          context.target
+        end
+      )
+    end
+
+    # Scope for evaluating method test definitions.
+    #
+    class Scope < TestCase::Scope
+
+      # Define a unit test for this case.
+      #
+      # @example
+      #   test "print message with new line to stdout" do
+      #     puts "Hello"
+      #   end
+      #
+      def test(label=nil, &block)
+        block = Omission.new(@_omit).to_proc if @_omit
+        test  = TestProc.new(
+          :context => @_testcase,
+          :setup   => @_setup,
+          :skip    => @_skip,
+          :label   => label,
+          &block
+        )
+        @_testcase.tests << test
+        test
+      end
+      alias :Test :test
+
+      # Create a sub-case ofr the method case.
+      def context(label, &block)
+        @_testcase.tests << TestMethod.new(
+          :context => @_testcase,
+          :target  => @_testcase.target,
+          :setup   => @_setup,
+          :skip    => @_skip,
+          :label   => label,
+          &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
+
+    end
+
+  end
+
+end