shoulda-context 1.0.0.beta1

data/CONTRIBUTION_GUIDELINES.rdoc

@@ -0,0 +1,10 @@
+We're using GitHub[http://github.com/thoughtbot/shoulda-context], and we've been getting any combination of github pull requests, tickets, patches, emails, etc.  We need to normalize this workflow to make sure we don't miss any fixes.
+
+* Make sure you're accessing the source from the {official repository}[http://github.com/thoughtbot/shoulda-context].
+* We prefer git branches over patches, but we can take either.
+* If you're using git, please make a branch for each separate contribution.  We can cherry pick your commits, but pulling from a branch is easier.
+* If you're submitting patches, please cut each fix or feature into a separate patch.
+* There should be an issue[http://github.com/thoughtbot/shoulda-context/issues] for any submission.  If you've found a bug and want to fix it, open a new ticket at the same time.
+* Please <b>don't send pull requests</b>  Just update the issue with the url for your fix (or attach the patch) when it's ready.  The github pull requests pretty much get dropped on the floor until someone with commit rights notices them in the mailbox.
+* Contributions without tests won't be accepted.  The file <tt>/test/README</tt> explains the testing system pretty thoroughly.
+

data/Gemfile

@@ -0,0 +1,5 @@
+source 'http://rubygems.org'
+
+gem 'mocha'
+gem 'ruby-debug'
+

data/Gemfile.lock

@@ -0,0 +1,20 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    columnize (0.3.2)
+    linecache (0.43)
+    mocha (0.9.10)
+      rake
+    rake (0.8.7)
+    ruby-debug (0.10.4)
+      columnize (>= 0.1)
+      ruby-debug-base (~> 0.10.4.0)
+    ruby-debug-base (0.10.4)
+      linecache (>= 0.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  mocha
+  ruby-debug

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2007, Tammer Saleh, Thoughtbot, Inc.
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,53 @@
+= shoulda-context
+
+{Official Documentation}[http://rubydoc.info/github/thoughtbot/shoulda-context/master/frames]
+
+Shoulda's contexts make it easy to write understandable and maintainable tests for Test::Unit.
+It's fully compatible with your existing tests in Test::Unit, and requires no retooling to use.
+
+Refer to the {shoulda}[https://github.com/thoughtbot/shoulda] gem if you want to know more
+about using shoulda with Rails or RSpec.
+
+== Contexts
+
+Instead of writing Ruby methods with lots_of_underscores, shoulda-context adds
+context, setup, and should blocks...
+
+  class CalculatorTest < Test::Unit::TestCase
+    context "a calculator" do
+      setup do
+        @calculator = Calculator.new
+      end
+
+      should "add two numbers for the sum" do
+        assert_equal 4, @calculator.sum(2, 2)
+      end
+
+      should "multiply two numbers for the product" do
+        assert_equal 10, @calculator.product(2, 5)
+      end
+    end
+  end
+
+... which combine to produce the following test methods:
+
+  "test: A User instance should return its full name."
+  "test: A User instance with a profile should return true when sent #has_profile?."
+
+== Assertions
+
+It also has two additional Test::Unit assertions for working with Ruby's Array:
+
+  assert_same_elements([:a, :b, :c], [:c, :a, :b])
+  assert_contains(['a', '1'], /\d/)
+  assert_contains(['a', '1'], 'a')
+
+= Credits
+
+Shoulda is maintained and funded by {thoughtbot}[http://thoughtbot.com/community].
+Thank you to all the {contributors}[https://github.com/thoughtbot/shoulda-context/contributors].
+
+= License
+
+Shoulda is Copyright © 2006-2010 thoughtbot, inc.
+It is free software, and may be redistributed under the terms specified in the MIT-LICENSE file.

data/Rakefile

@@ -0,0 +1,44 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+$LOAD_PATH.unshift("lib")
+load 'tasks/shoulda.rake'
+
+test_files_pattern = 'test/**/*_test.rb'
+Rake::TestTask.new do |t|
+  t.libs << 'lib' << 'test'
+  t.pattern = test_files_pattern
+  t.verbose = false
+end
+
+Rake::RDocTask.new { |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title    = "shoulda-context -- Context framework for Test::Unit"
+  rdoc.options << '--line-numbers'
+  rdoc.template = "#{ENV['template']}.rb" if ENV['template']
+  rdoc.rdoc_files.include('README.rdoc', 'CONTRIBUTION_GUIDELINES.rdoc', 'lib/**/*.rb')
+}
+
+desc "Run code-coverage analysis using rcov"
+task :coverage do
+  rm_rf "coverage"
+  files = Dir[test_files_pattern]
+  system "rcov --rails --sort coverage -Ilib #{files.join(' ')}"
+end
+
+eval("$specification = begin; #{IO.read('shoulda-context.gemspec')}; end")
+Rake::GemPackageTask.new $specification do |pkg|
+  pkg.need_tar = true
+  pkg.need_zip = true
+end
+
+desc "Clean files generated by rake tasks"
+task :clobber => [:clobber_rdoc, :clobber_package]
+
+desc 'Default: run tests'
+task :default => [:test]
+

data/bin/convert_to_should_syntax

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+require 'fileutils'
+require 'tmpdir'
+
+TMP = Dir::tmpdir
+
+def usage(msg = nil)
+  puts "Error: #{msg}" if msg
+  puts if msg
+  puts "Usage: #{File.basename(__FILE__)} normal_test_file.rb"
+  puts
+  puts "Will convert an existing test file with names like "
+  puts
+  puts "  def test_should_do_stuff"
+  puts "    ..."
+  puts "  end"
+  puts
+  puts "to one using the new syntax: "
+  puts
+  puts "  should \"be super cool\" do"
+  puts "    ..."
+  puts "  end"
+  puts
+  puts "A copy of the old file will be left under #{TMP} in case\nthis script just seriously screws up"
+  puts
+  exit (msg ? 2 : 0)
+end
+
+usage("Wrong number of arguments.") unless ARGV.size == 1
+usage("Temp directory '#{TMP}' is not valid. Set TMPDIR environment variable to a writeable directory.") unless File.directory?(TMP) && File.writable?(TMP)
+
+file = ARGV.shift
+tmpfile = File.join(TMP, File.basename(file))
+usage("File '#{file}' doesn't exist") unless File.exists?(file)
+
+FileUtils.cp(file, tmpfile)
+contents = File.read(tmpfile)
+contents.gsub!(/def test_should_(\S+)/) {|line| "should \"#{$1.tr('_', ' ')}\" do"}
+contents.gsub!(/def test_(\S+)/) {|line| "should \"RENAME ME: test #{$1.tr('_', ' ')}\" do"}
+File.open(file, 'w') { |f| f.write(contents) }
+
+puts "File '#{file}' has been converted to 'should' syntax.  Old version has been stored in '#{tmpfile}'"

data/lib/shoulda-context.rb

@@ -0,0 +1,12 @@
+require 'test/unit'
+require 'shoulda/context/version'
+require 'shoulda/context/proc_extensions'
+require 'shoulda/context/assertions'
+require 'shoulda/context/context'
+require 'shoulda/context/autoload_macros'
+
+class Test::Unit::TestCase
+  include Shoulda::Context::Assertions
+  include Shoulda::Context::InstanceMethods
+  extend Shoulda::Context::ClassMethods
+end

data/lib/shoulda/context/assertions.rb

@@ -0,0 +1,81 @@
+module Shoulda # :nodoc:
+  module Context
+    module Assertions
+      # Asserts that two arrays contain the same elements, the same number of times.  Essentially ==, but unordered.
+      #
+      #   assert_same_elements([:a, :b, :c], [:c, :a, :b]) => passes
+      def assert_same_elements(a1, a2, msg = nil)
+        [:select, :inject, :size].each do |m|
+          [a1, a2].each {|a| assert_respond_to(a, m, "Are you sure that #{a.inspect} is an array?  It doesn't respond to #{m}.") }
+        end
+
+        assert a1h = a1.inject({}) { |h,e| h[e] = a1.select { |i| i == e }.size; h }
+        assert a2h = a2.inject({}) { |h,e| h[e] = a2.select { |i| i == e }.size; h }
+
+        assert_equal(a1h, a2h, msg)
+      end
+
+      # Asserts that the given collection contains item x.  If x is a regular expression, ensure that
+      # at least one element from the collection matches x.  +extra_msg+ is appended to the error message if the assertion fails.
+      #
+      #   assert_contains(['a', '1'], /\d/) => passes
+      #   assert_contains(['a', '1'], 'a') => passes
+      #   assert_contains(['a', '1'], /not there/) => fails
+      def assert_contains(collection, x, extra_msg = "")
+        collection = [collection] unless collection.is_a?(Array)
+        msg = "#{x.inspect} not found in #{collection.to_a.inspect} #{extra_msg}"
+        case x
+        when Regexp
+          assert(collection.detect { |e| e =~ x }, msg)
+        else
+          assert(collection.include?(x), msg)
+        end
+      end
+
+      # Asserts that the given collection does not contain item x.  If x is a regular expression, ensure that
+      # none of the elements from the collection match x.
+      def assert_does_not_contain(collection, x, extra_msg = "")
+        collection = [collection] unless collection.is_a?(Array)
+        msg = "#{x.inspect} found in #{collection.to_a.inspect} " + extra_msg
+        case x
+        when Regexp
+          assert(!collection.detect { |e| e =~ x }, msg)
+        else
+          assert(!collection.include?(x), msg)
+        end
+      end
+
+      # Asserts that the given matcher returns true when +target+ is passed to #matches?
+      def assert_accepts(matcher, target, options = {})
+        if matcher.respond_to?(:in_context)
+          matcher.in_context(self)
+        end
+
+        if matcher.matches?(target)
+          assert_block { true }
+          if options[:message]
+            assert_match options[:message], matcher.negative_failure_message
+          end
+        else
+          assert_block(matcher.failure_message) { false }
+        end
+      end
+
+      # Asserts that the given matcher returns false when +target+ is passed to #matches?
+      def assert_rejects(matcher, target, options = {})
+        if matcher.respond_to?(:in_context)
+          matcher.in_context(self)
+        end
+
+        unless matcher.matches?(target)
+          assert_block { true }
+          if options[:message]
+            assert_match options[:message], matcher.failure_message
+          end
+        else
+          assert_block(matcher.negative_failure_message) { false }
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/context/autoload_macros.rb

@@ -0,0 +1,46 @@
+module Shoulda # :nodoc:
+  # Call autoload_macros when you want to load test macros automatically in a non-Rails
+  # project (it's done automatically for Rails projects).
+  # You don't need to specify ROOT/test/shoulda_macros explicitly. Your custom macros
+  # are loaded automatically when you call autoload_macros.
+  #
+  # The first argument is the path to you application's root directory.
+  # All following arguments are directories relative to your root, which contain
+  # shoulda_macros subdirectories. These directories support the same kinds of globs as the
+  # Dir class.
+  #
+  # Basic usage (from a test_helper):
+  # Shoulda.autoload_macros(File.dirname(__FILE__) + '/..')
+  # will load everything in
+  # - your_app/test/shoulda_macros
+  #
+  # To load vendored macros as well:
+  # Shoulda.autoload_macros(APP_ROOT, 'vendor/*')
+  # will load everything in
+  # - APP_ROOT/vendor/*/shoulda_macros
+  # - APP_ROOT/test/shoulda_macros
+  #
+  # To load macros in an app with a vendor directory laid out like Rails':
+  # Shoulda.autoload_macros(APP_ROOT, 'vendor/{plugins,gems}/*')
+  # or
+  # Shoulda.autoload_macros(APP_ROOT, 'vendor/plugins/*', 'vendor/gems/*')
+  # will load everything in
+  # - APP_ROOT/vendor/plugins/*/shoulda_macros
+  # - APP_ROOT/vendor/gems/*/shoulda_macros
+  # - APP_ROOT/test/shoulda_macros
+  #
+  # If you prefer to stick testing dependencies away from your production dependencies:
+  # Shoulda.autoload_macros(APP_ROOT, 'vendor/*', 'test/vendor/*')
+  # will load everything in
+  # - APP_ROOT/vendor/*/shoulda_macros
+  # - APP_ROOT/test/vendor/*/shoulda_macros
+  # - APP_ROOT/test/shoulda_macros
+  def self.autoload_macros(root, *dirs)
+    dirs << File.join('test')
+    complete_dirs = dirs.map{|d| File.join(root, d, 'shoulda_macros')}
+    all_files     = complete_dirs.inject([]){ |files, dir| files + Dir[File.join(dir, '*.rb')] }
+    all_files.each do |file|
+      require file
+    end
+  end
+end

data/lib/shoulda/context/context.rb

@@ -0,0 +1,446 @@
+module Shoulda
+  module Context
+    class << self
+      attr_accessor :contexts
+      def contexts # :nodoc:
+        @contexts ||= []
+      end
+
+      def current_context # :nodoc:
+        self.contexts.last
+      end
+
+      def add_context(context) # :nodoc:
+        self.contexts.push(context)
+      end
+
+      def remove_context # :nodoc:
+        self.contexts.pop
+      end
+    end
+
+    module ClassMethods
+      # == Should statements
+      #
+      # Should statements are just syntactic sugar over normal Test::Unit test
+      # methods.  A should block contains all the normal code and assertions
+      # you're used to seeing, with the added benefit that they can be wrapped
+      # inside context blocks (see below).
+      #
+      # === Example:
+      #
+      #  class UserTest < Test::Unit::TestCase
+      #
+      #    def setup
+      #      @user = User.new("John", "Doe")
+      #    end
+      #
+      #    should "return its full name"
+      #      assert_equal 'John Doe', @user.full_name
+      #    end
+      #
+      #  end
+      #
+      # ...will produce the following test:
+      # * <tt>"test: User should return its full name. "</tt>
+      #
+      # Note: The part before <tt>should</tt> in the test name is gleamed from the name of the Test::Unit class.
+      #
+      # Should statements can also take a Proc as a <tt>:before </tt>option.  This proc runs after any
+      # parent context's setups but before the current context's setup.
+      #
+      # === Example:
+      #
+      #  context "Some context" do
+      #    setup { puts("I run after the :before proc") }
+      #
+      #    should "run a :before proc", :before => lambda { puts("I run before the setup") }  do
+      #      assert true
+      #    end
+      #  end
+      #
+      # Should statements can also wrap matchers, making virtually any matcher
+      # usable in a macro style. The matcher's description is used to generate a
+      # test name and failure message, and the test will pass if the matcher
+      # matches the subject.
+      #
+      # === Example:
+      #
+      #   should validate_presence_of(:first_name).with_message(/gotta be there/)
+      #
+
+      def should(name_or_matcher, options = {}, &blk)
+        if Shoulda::Context.current_context
+          Shoulda::Context.current_context.should(name_or_matcher, options, &blk)
+        else
+          context_name = self.name.gsub(/Test/, "")
+          context = Shoulda::Context::Context.new(context_name, self) do
+            should(name_or_matcher, options, &blk)
+          end
+          context.build
+        end
+      end
+
+      # Allows negative tests using matchers. The matcher's description is used
+      # to generate a test name and negative failure message, and the test will
+      # pass unless the matcher matches the subject.
+      #
+      # === Example:
+      #
+      #   should_not set_the_flash
+      def should_not(matcher)
+        if Shoulda::Context.current_context
+          Shoulda::Context.current_context.should_not(matcher)
+        else
+          context_name = self.name.gsub(/Test/, "")
+          context = Shoulda::Context::Context.new(context_name, self) do
+            should_not(matcher)
+          end
+          context.build
+        end
+      end
+
+      # == Before statements
+      #
+      # Before statements are should statements that run before the current
+      # context's setup. These are especially useful when setting expectations.
+      #
+      # === Example:
+      #
+      #  class UserControllerTest < Test::Unit::TestCase
+      #    context "the index action" do
+      #      setup do
+      #        @users = [Factory(:user)]
+      #        User.stubs(:find).returns(@users)
+      #      end
+      #
+      #      context "on GET" do
+      #        setup { get :index }
+      #
+      #        should respond_with(:success)
+      #
+      #        # runs before "get :index"
+      #        before_should "find all users" do
+      #          User.expects(:find).with(:all).returns(@users)
+      #        end
+      #      end
+      #    end
+      #  end
+      def before_should(name, &blk)
+        should(name, :before => blk) { assert true }
+      end
+
+      # Just like should, but never runs, and instead prints an 'X' in the Test::Unit output.
+      def should_eventually(name, options = {}, &blk)
+        context_name = self.name.gsub(/Test/, "")
+        context = Shoulda::Context::Context.new(context_name, self) do
+          should_eventually(name, &blk)
+        end
+        context.build
+      end
+
+      # == Contexts
+      #
+      # A context block groups should statements under a common set of setup/teardown methods.
+      # Context blocks can be arbitrarily nested, and can do wonders for improving the maintainability
+      # and readability of your test code.
+      #
+      # A context block can contain setup, should, should_eventually, and teardown blocks.
+      #
+      #  class UserTest < Test::Unit::TestCase
+      #    context "A User instance" do
+      #      setup do
+      #        @user = User.find(:first)
+      #      end
+      #
+      #      should "return its full name"
+      #        assert_equal 'John Doe', @user.full_name
+      #      end
+      #    end
+      #  end
+      #
+      # This code will produce the method <tt>"test: A User instance should return its full name. "</tt>.
+      #
+      # Contexts may be nested.  Nested contexts run their setup blocks from out to in before each
+      # should statement.  They then run their teardown blocks from in to out after each should statement.
+      #
+      #  class UserTest < Test::Unit::TestCase
+      #    context "A User instance" do
+      #      setup do
+      #        @user = User.find(:first)
+      #      end
+      #
+      #      should "return its full name"
+      #        assert_equal 'John Doe', @user.full_name
+      #      end
+      #
+      #      context "with a profile" do
+      #        setup do
+      #          @user.profile = Profile.find(:first)
+      #        end
+      #
+      #        should "return true when sent :has_profile?"
+      #          assert @user.has_profile?
+      #        end
+      #      end
+      #    end
+      #  end
+      #
+      # This code will produce the following methods
+      # * <tt>"test: A User instance should return its full name. "</tt>
+      # * <tt>"test: A User instance with a profile should return true when sent :has_profile?. "</tt>
+      #
+      # <b>Just like should statements, a context block can exist next to normal <tt>def test_the_old_way; end</tt>
+      # tests</b>.  This means you do not have to fully commit to the context/should syntax in a test file.
+
+      def context(name, &blk)
+        if Shoulda::Context.current_context
+          Shoulda::Context.current_context.context(name, &blk)
+        else
+          context = Shoulda::Context::Context.new(name, self, &blk)
+          context.build
+        end
+      end
+
+      # Returns the class being tested, as determined by the test class name.
+      #
+      #   class UserTest; described_type; end
+      #   # => User
+      def described_type
+        @described_type ||= self.name.
+          gsub(/Test$/, '').
+          split('::').
+          inject(Object) { |parent, local_name| parent.const_get(local_name) }
+      end
+
+      # Sets the return value of the subject instance method:
+      #
+      #   class UserTest < Test::Unit::TestCase
+      #     subject { User.first }
+      #
+      #     # uses the existing user
+      #     should validate_uniqueness_of(:email)
+      #   end
+      def subject(&block)
+        @subject_block = block
+      end
+
+      def subject_block # :nodoc:
+        @subject_block
+      end
+    end
+
+    module InstanceMethods
+      # Returns an instance of the class under test.
+      #
+      #   class UserTest
+      #     should "be a user" do
+      #       assert_kind_of User, subject # passes
+      #     end
+      #   end
+      #
+      # The subject can be explicitly set using the subject class method:
+      #
+      #   class UserTest
+      #     subject { User.first }
+      #     should "be an existing user" do
+      #       assert !subject.new_record? # uses the first user
+      #     end
+      #   end
+      #
+      # The subject is used by all macros that require an instance of the class
+      # being tested.
+      def subject
+        @shoulda_subject ||= construct_subject
+      end
+
+      def subject_block # :nodoc:
+        (@shoulda_context && @shoulda_context.subject_block) || self.class.subject_block
+      end
+
+      def get_instance_of(object_or_klass) # :nodoc:
+        if object_or_klass.is_a?(Class)
+          object_or_klass.new
+        else
+          object_or_klass
+        end
+      end
+
+      def instance_variable_name_for(klass) # :nodoc:
+        klass.to_s.split('::').last.underscore
+      end
+
+      private
+
+      def construct_subject
+        if subject_block
+          instance_eval(&subject_block)
+        else
+          get_instance_of(self.class.described_type)
+        end
+      end
+    end
+
+    class Context # :nodoc:
+
+      attr_accessor :name               # my name
+      attr_accessor :parent             # may be another context, or the original test::unit class.
+      attr_accessor :subcontexts        # array of contexts nested under myself
+      attr_accessor :setup_blocks       # blocks given via setup methods
+      attr_accessor :teardown_blocks    # blocks given via teardown methods
+      attr_accessor :shoulds            # array of hashes representing the should statements
+      attr_accessor :should_eventuallys # array of hashes representing the should eventually statements
+      attr_accessor :subject_block
+
+      def initialize(name, parent, &blk)
+        Shoulda::Context.add_context(self)
+        self.name               = name
+        self.parent             = parent
+        self.setup_blocks       = []
+        self.teardown_blocks    = []
+        self.shoulds            = []
+        self.should_eventuallys = []
+        self.subcontexts        = []
+
+        merge_block(&blk)
+        Shoulda::Context.remove_context
+      end
+
+      def merge_block(&blk)
+        blk.bind(self).call
+      end
+
+      def context(name, &blk)
+        self.subcontexts << Context.new(name, self, &blk)
+      end
+
+      def setup(&blk)
+        self.setup_blocks << blk
+      end
+
+      def teardown(&blk)
+        self.teardown_blocks << blk
+      end
+
+      def should(name_or_matcher, options = {}, &blk)
+        if name_or_matcher.respond_to?(:description) && name_or_matcher.respond_to?(:matches?)
+          name = name_or_matcher.description
+          blk = lambda { assert_accepts name_or_matcher, subject }
+        else
+          name = name_or_matcher
+        end
+
+        if blk
+          self.shoulds << { :name => name, :before => options[:before], :block => blk }
+        else
+         self.should_eventuallys << { :name => name }
+       end
+      end
+
+      def should_not(matcher)
+        name = matcher.description
+        blk = lambda { assert_rejects matcher, subject }
+        self.shoulds << { :name => "not #{name}", :block => blk }
+      end
+
+      def should_eventually(name, &blk)
+        self.should_eventuallys << { :name => name, :block => blk }
+      end
+
+      def subject(&block)
+        self.subject_block = block
+      end
+
+      def subject_block
+        return @subject_block if @subject_block
+        parent.subject_block
+      end
+
+      def full_name
+        parent_name = parent.full_name if am_subcontext?
+        return [parent_name, name].join(" ").strip
+      end
+
+      def am_subcontext?
+        parent.is_a?(self.class) # my parent is the same class as myself.
+      end
+
+      def test_unit_class
+        am_subcontext? ? parent.test_unit_class : parent
+      end
+
+      def test_methods
+        @test_methods ||= Hash.new { |h,k|
+          h[k] = Hash[k.instance_methods.map { |n| [n, true] }]
+        }
+      end
+
+      def create_test_from_should_hash(should)
+        test_name = ["test:", full_name, "should", "#{should[:name]}. "].flatten.join(' ').to_sym
+
+        if test_methods[test_unit_class][test_name.to_s] then
+          warn "  * WARNING: '#{test_name}' is already defined"
+        end
+
+        test_methods[test_unit_class][test_name.to_s] = true
+
+        context = self
+        test_unit_class.send(:define_method, test_name) do
+          @shoulda_context = context
+          begin
+            context.run_parent_setup_blocks(self)
+            should[:before].bind(self).call if should[:before]
+            context.run_current_setup_blocks(self)
+            should[:block].bind(self).call
+          ensure
+            context.run_all_teardown_blocks(self)
+          end
+        end
+      end
+
+      def run_all_setup_blocks(binding)
+        run_parent_setup_blocks(binding)
+        run_current_setup_blocks(binding)
+      end
+
+      def run_parent_setup_blocks(binding)
+        self.parent.run_all_setup_blocks(binding) if am_subcontext?
+      end
+
+      def run_current_setup_blocks(binding)
+        setup_blocks.each do |setup_block|
+          setup_block.bind(binding).call
+        end
+      end
+
+      def run_all_teardown_blocks(binding)
+        teardown_blocks.reverse.each do |teardown_block|
+          teardown_block.bind(binding).call
+        end
+        self.parent.run_all_teardown_blocks(binding) if am_subcontext?
+      end
+
+      def print_should_eventuallys
+        should_eventuallys.each do |should|
+          test_name = [full_name, "should", "#{should[:name]}. "].flatten.join(' ')
+          puts "  * DEFERRED: " + test_name
+        end
+      end
+
+      def build
+        shoulds.each do |should|
+          create_test_from_should_hash(should)
+        end
+
+        subcontexts.each { |context| context.build }
+
+        print_should_eventuallys
+      end
+
+      def method_missing(method, *args, &blk)
+        test_unit_class.send(method, *args, &blk)
+      end
+
+    end
+  end
+end