citron 0.2.0 → 0.3.0

data/.ruby

@@ -1,50 +1,47 @@
---- 
-authors: 
+---
+source:
+- PROFILE
+authors:
 - name: Thomas Sawyer
   email: transfire@gmail.com
-copyrights: 
+copyrights:
 - holder: Thomas Sawyer
-  year: "2011"
+  year: '2011'
   license: BSD-2-Clause
-replacements: []
-
-conflicts: []
-
-requirements: 
-- name: test
+requirements:
+- name: rubytest
 - name: ae
 - name: detroit
-  groups: 
+  groups:
   - build
   development: true
 - name: reap
-  groups: 
+  groups:
   - build
   development: true
 - name: qed
-  groups: 
+  groups:
   - test
   development: true
 dependencies: []
-
-repositories: 
+alternatives: []
+conflicts: []
+repositories:
 - uri: git://github.com/proutils/citron.git
   scm: git
   name: upstream
-resources: 
+resources:
   home: http://rubyworks.github.com/citron
   code: http://github.com/rubyworks/citron
-load_path: 
+extra: {}
+load_path:
 - lib
-extra: 
-  manifest: MANIFEST
-alternatives: []
-
 revision: 0
 name: citron
 title: Citron
+version: 0.3.0
 summary: Classic Unit-style Test Framework
-description: Citron is a unit testing framework with a classic test-case/test-unit style.
+description: Citron is a unit testing framework with a classic test-case/test-unit
+  style.
 organization: RubyWorks
-version: 0.2.0
-date: "2011-08-12"
+date: '2012-02-25'

data/{COPYING.rdoc → COPYING.md}

@@ -1,12 +1,18 @@
-= COPYRIGHT NOTICES
+# COPYRIGHT
 
-== Citron
 
-Copyright:: (c) 2011 Thomas Sawyer, RubyWorks
-License:: BSD-2-Clause
-Website:: http://rubyworks.github.com/citron
+## NOTICES
 
-    Copyright 2011 Thomas Sawyer. All rights reserved.
+### Citron
+
+http://rubyworks.github.com/citron
+
+* Copyright (c) 2011 Rubyworks (BSD-2-Clause)
+
+
+## LICENSES
+
+### BSD-2-Clause
 
     Redistribution and use in source and binary forms, with or without
     modification, are permitted provided that the following conditions are met:

data/HISTORY.md

@@ -0,0 +1,22 @@
+# Release History
+
+## 0.3.0 / 2012-02-25
+
+This release cleans up the code, deprecates the complex Before and After
+advice, adds soem additional support for RubyTests lesser known features.
+
+Changes:
+
+* Deprecated Before and After advice.
+* Add support for #unit and #source_location.
+* Setup/terdown is inherited by subcases.
+
+
+## 0.2.0 / 2011-08-11
+
+This is the first usable release of Citron.
+
+Changes:
+
+* General improvements.
+

data/{README.rdoc → README.md}

@@ -1,20 +1,17 @@
-= Citron
+# Citron
 
-{Homepage}[http://rubyworks.github.com/citron] -
-{Development}[http://github.com/rubyworks/citron]
+[Website](http://rubyworks.github.com/citron) /
+[Development](http://github.com/rubyworks/citron) /
+[Report Issue](http://github.com/rubyworks/citron/issues) /
 
-Author:: Thomas Sawyer
-License:: FreeBSD
-Copyright:: (c) 2011 Thomas Sawyer, Rubyworks
 
+## Description
 
-== Description
+Citron is a traditional unit test framework. It defines a simple
+domain language for creating classically styled unit tests.
 
-Citron is a classic unit test framework. It defines a simple
-domain language for create classic-style tests.
 
-
-== Example
+## Example
 
 Here's a fun example.
 
@@ -55,11 +52,11 @@ Here's a fun example.
     end
 
 
-== License
+## Copyrights
 
-Copyright (c) 2011 Thomas Sawyer, Rubyworks
+Copyright (c) 2011 Rubyworks
 
-Citron is distributed according to the terms of the FreeBSD license.
+Citron is distributable according to the terms of the **FreeBSD** license.
 
-See COPYING.rd for details.
+See COPYING.md for details.
 

data/lib/citron.rb

@@ -1,16 +1,16 @@
-module Citron
-  $TEST_SUITE ||= []
+$TEST_SUITE ||= []
 
-  require 'citron/test_case'
-  require 'citron/test_proc'
-  require 'citron/test_advice'
+module Citron
+  require 'citron/world'
   require 'citron/test_setup'
-end
+  require 'citron/test_teardown'
+  require 'citron/test_proc'
+  require 'citron/test_case'
 
-module Citron
   module DSL
-
+    #
     # Define a general test case.
+    #
     def test_case(label, &block)
       $TEST_SUITE << Citron::TestCase.new(:label=>label, &block)
     end
@@ -18,6 +18,8 @@ module Citron
     alias :TestCase :test_case
     alias :testcase :test_case
   end
+
 end
 
 extend Citron::DSL
+

data/lib/citron/test_case.rb

@@ -1,10 +1,3 @@
-#require 'citron/pending'
-#require 'citron/test_context'
-require 'citron/test_advice'
-require 'citron/test_setup'
-require 'citron/test_proc'
-require 'citron/world'
-
 module Citron
 
   # Test Case encapsulates a collection of
@@ -18,30 +11,41 @@ module Citron
     # Brief description of the test case.
     attr :label
 
+    # Symbol list of tags. Trailing element may be Hash
+    # of `symbol => object`.
+    attr :tags
+
     # List of tests and sub-cases.
     attr :tests
 
-    # The setup and teardown advice.
+    # The setup advice.
     attr :setup
 
-    # Pattern mathing before and after advice.
-    attr :advice
+    # The teardown advice.
+    attr :teardown
+
+    # Code unit that is subject of test case.
+    attr :unit
 
     # Module for evaluating tests.
     attr :scope
 
-    # A test case +target+ is a class or module.
+  private
+
+    # Initialize new TestCase.
     #
     def initialize(settings={}, &block)
       @context = settings[:context]
       @label   = settings[:label]
-      @setup   = settings[:setup]
+      @tags    = settings[:tags]
+      #@setup  = settings[:setup]
       @skip    = settings[:skip]
 
-      if @context
-        @advice = context.advice.clone
-      else
-        @advice = TestAdvice.new
+      @unit    = calc_unit
+
+      if context
+        @setup    = context.setup.copy(self)    if context.setup
+        @teardown = context.teardown.copy(self) if context.teardown
       end
 
       @tests = []
@@ -51,141 +55,235 @@ module Citron
       @scope.module_eval(&block) if block
     end
 
+    #
+    def calc_unit
+      case @label
+      when Module, Class
+        @label
+      when /^(\.|\#|\:\:)\w+/
+        if @context && Module === @context.unit
+          [@context.unit, @label].join('')
+        else
+          @label
+        end
+      end
+    end
+
+  public
+
+    #
+    # Assign the setup procedure
+    #
+    # @param [TestSetup] test_setup
+    #
+    def setup=(test_setup)
+      @setup = test_setup
+    end
+
+    #
+    # Assign the teardown procedure.
+    #
+    # @param [TestTeardown] test_teardown
+    #
+    def teardown=(test_teardown)
+      @teardown = test_teardown
+    end
+
+    #
+    # Add new test or sub-case.
+    #
+    # @param [TestCase,TestProc] test_obejct
+    #   Test sub-case or procedure to add to this case.
     #
     def <<(test_object)
       @tests << test_object
     end
 
-    # Iterate over each test and subcase.
+    #
+    # Iterate over each test and sub-case.
+    #
+    # @param [Proc] block
+    #   Iteration procedure.
+    #
     def each(&block)
       tests.each(&block)
     end
 
-    # Number of tests plus subcases.
+    # 
+    #def call
+    #  yield
+    #end
+
+    #
+    # Number of tests and sub-cases.
+    #
+    # @return [Fixnum] size
+    #
     def size
       tests.size
     end
 
+    #
     # Subclasses of TestCase can override this to describe
     # the type of test case they define.
-    def type
-      'Case'
-    end
+    #
+    # @return [String]
+    #
+    #def type
+    #  'TestCase'
+    #end
 
+    #
+    # Test case label.
+    #
+    # @return [String]
     #
     def to_s
       label.to_s
     end
 
+    #
+    # Is test case to be skipped?
+    #
+    # @return [Boolean,String]
+    #   If +false+ or +nil+ if not skipped, otherwise
+    #   +true+ or a string explain why to skip.
     #
     def skip?
       @skip
     end
 
+    #
+    # Set test case to be skipped.
+    #
+    # @param [Boolean,String] reason
+    #   Set to +false+ or +nil+ if not skipped, otherwise
+    #   +true+ or a string explain why to skip.
     #
     def skip=(reason)
       @skip = reason
     end
 
-    # Run test in the context of this case.
+    def test_scope
+      @test_scope ||= TestProc::Scope.new(scope)
+    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
+    def run(test)
+      setup.call(test_scope) if setup
+      #scope.instance_exec(*arguments, &procedure)
+      test_scope.instance_eval(&test.procedure)
+      teardown.call(test_scope) if teardown
     end
 
+    # The evaluation scope for a test case.
     #
     class Scope < World
 
-      # Setup new evaluation scope.
+      #
+      # Initialize new evaluation scope.
+      #
+      # @param [TestCase] testcase
+      #   The test case this scope belongs.
+      #
       def initialize(testcase) #, &code)
         @_case  = testcase
         @_setup = testcase.setup
         @_skip  = false
 
         if testcase.context
-          extend(testcase.context.scope)
+          include(testcase.context.scope)
         end
       end
 
-      #--
-      # TODO: Instead of reusing TestCase can we have a TestContext
-      #       that more generically mimics it's context context?
-      #++
-
+      #
       # Create a sub-case.
-      def Context(label, &block)
+      #
+      # @param [String] label
+      #   The breif description of the test case.
+      #
+      # @param [Array<Symbol,Hash>] tags
+      #   List of symbols with optional trailing `symbol=>object` hash.
+      #   These can be used as a means of filtering tests.
+      #
+      def Context(label, *tags, &block)
         settings = {
           :context => @_case,
-          :setup   => @_setup,
+          #:setup   => @_setup,
           :skip    => @_skip,
-          :label   => label
+          :label   => label,
+          :tags    => tags
         }
+
         testcase = TestCase.new(settings, &block)
+
         @_case.tests << testcase
+
         testcase
       end
 
       alias :context :Context
 
-      # Create a test.
-      def Test(label=nil, &procedure)
+      #
+      # Create a test, or a parameterized test.
+      #
+      # @param [String] label
+      #   The breif description of the test case.
+      #
+      # @param [Array<Symbol,Hash>] tags
+      #   List of symbols with optional trailing `symbol=>object` hash.
+      #   These can be used as a means of filtering tests.
+      #
+      def Test(label=nil, *tags, &procedure)
+        file, line, _ = *caller[0].split(':')
+
         settings = {
           :context => @_case,
-          :setup   => @_setup,
+          #:setup   => @_setup,
           :skip    => @_skip,
-          :label   => label
+          :label   => label,
+          :tags    => tags,
+          :file    => file,
+          :line    => line
         }
-        testunit = TestProc.new(settings, &procedure)
-        if procedure.arity == 0
-          @_case.tests << testunit
+
+        if procedure.arity == 0 || (RUBY_VERSION < '1.9' && procedure.arity == -1)
+          test = TestProc.new(settings, &procedure)
+          @_case.tests << test
+          @_test = nil
+          test
         else
-          @_test = testunit
+          @_test = [settings, procedure]
         end
-        testunit
       end
 
       alias :test :Test
 
       #
+      # Actualize a parameterized test.
+      #
+      # @todo Better name than `Ok` ?
       #
       def Ok(*args)
-        test = @_test
-        test.arguments = args
-        @_case << test
-        @_test = nil
-        return test
-      end
+        settings, procedure = *@_test
 
-      alias :ok :Ok
+        test = TestProc.new(settings) do
+          procedure.call(*args)
+        end
 
-      #
-      #
-      def No(*args)
-        test = @_test
-        test.arguments = args
-        test.negate    = true
         @_case << test
-        @_test = nil
+
         return test
       end
 
-      alias :no :No
+      alias :ok :Ok
 
+      #
       # Setup is used to set things up for each unit test.
       # The setup procedure is run before each unit.
       #
@@ -193,97 +291,59 @@ module Citron
       #   A brief description of what the setup procedure sets-up.
       #
       def Setup(label=nil, &proc)
-        @_setup = TestSetup.new(@_case, label, &proc)
+        if proc
+          @_case.setup    = TestSetup.new(@_case, label, &proc)
+          @_case.teardown = nil  # if the setup is reset, then so it the teardown
+        else
+          @_case.setup
+        end
       end
 
       alias :setup :Setup
 
-      #alias_method :Concern, :Setup
-      #alias_method :concern, :Setup
-
+      #
       # Teardown procedure is used to clean-up after each unit test.
       #
       def Teardown(&proc)
-        @_setup.teardown = proc
+        if proc
+          @_case.teardown = TestTeardown.new(@_case, &proc)
+        else
+          @_case.teardown
+        end
       end
 
       alias :teardown :Teardown
 
-      # 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.
+      # Mark tests or sub-cases to be skipped. If block is given, then
+      # tests defined within the block are skipped. Without a block
+      # all subsquent tests defined in a context will be skipped.
       #
-      def Before(*matches, &procedure)
-        @_case.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.
+      # @param [Boolean,String] reason
+      #   Set to +false+ or +nil+ if not skipped, otherwise
+      #   +true+ or a string explain why to skip.
       #
       # @example
-      #   Method :puts do
-      #     Test "standard output (@stdout)" do
-      #       puts "Hello"
-      #     end
-      #
-      #     Before /@stdout/ do
-      #       $stdout = StringIO.new
-      #     end
-      #
-      #     After /@stdout/ do
-      #       $stdout = STDOUT
+      #   skip("awaiting new feature") do
+      #     test "some test" do
+      #       ...
       #     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)
-        @_case.advice[:after][matches] = procedure
-      end
-
-      alias :after :After
-
-      # Mark tests or subcases to be skipped.
-      #
       # @example
-      #   skip("reason for skipping") do
-      #     test "some test" do
-      #       ...
-      #     end
+      #   skip("not on jruby") if jruby?
+      #   test "some test" do
+      #     ...
       #   end
       #
       def Skip(reason=true, &block)
-        @_skip = reason
-        block.call
-        @_skip = false
+        if block
+          @_skip = reason
+          block.call if block
+          @_skip = false
+        else
+          @_skip = reason
+        end
       end
 
       alias :skip :Skip