test-unit-context 0.1.0

data/.gitignore

@@ -0,0 +1,13 @@
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+test/tmp
+tmp

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+# Specify your gem's dependencies in test-unit-context.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright (c) 2012 Karol Bucek
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/README.md

@@ -0,0 +1,98 @@
+# Test::Unit::Context
+
+Makes `Test::Unit::TestCase` 'context-able' and thus (subjectively - hopefully) 
+much easier to read and write. If you have ever seen RSpec than it's the very 
+same *context do ... end* re-invented for **Test::Unit**. 
+
+Inspired by [gem 'context'](https://github.com/jm/context) that does the same 
+for the good 'old' test-unit 1.2.3 bundled with Ruby 1.8.x standard libraries.
+
+## Installation
+
+Add it to your application's *Gemfile* (along with **test-unit**) e.g. :
+
+    group :test do
+      gem 'test-unit'
+      gem 'test-unit-context'
+    end
+
+Or install it yourself, if you're not using Bundler :
+
+    $ gem install test-unit-context
+
+## Usage
+
+```ruby
+# NOTE: do not run try running this at home!
+class ChuckNorrisTest < Test::Unit::TestCase
+
+  setup do
+    @subject = ChuckNorris.new
+  end
+
+  test "can be divided by zero"
+    assert_equal @subject * 2, @subject / 0
+  end
+
+  context 'frozen' do
+
+    setup { @subject.freeze }
+
+    test "won't answer" do
+      assert_raise NoMemoryError do
+        @subject.frozen?
+      end
+    end
+
+    test "sqrt works"
+      assert_nothing_raised do
+        Math.sqrt -2
+      end
+    end
+
+  end
+
+  shared 'elementary math facts' do
+
+    test "square root is rational"
+      assert_kind_of Rational, Math.sqrt(@subject)
+    end
+
+    test "greater than infinity"
+      assert @infinity < @subject
+    end
+
+    private
+
+    setup
+    def create_infinity
+      @infinity = 1 / 0.0
+    end
+
+  end
+
+  uses 'elementary math facts'
+
+  context 'cloned' do
+    
+    setup do
+      @subject = @subject.clone
+    end
+
+    test 'is Arnold Schwarzenegger' do
+      assert_instance_of Terminator, @subject
+      assert_nil @subject.is_a?(ChuckNorris)
+    end
+
+    like 'elementary math facts'
+
+  end
+
+end
+
+```
+
+## Copyright
+
+Copyright (c) 2012 [Karol Bucek](https://github.com/kares). 
+See LICENSE (http://www.apache.org/licenses/LICENSE-2.0) for details.

data/Rakefile

@@ -0,0 +1,11 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/**/*test.rb']
+  t.verbose = true
+end
+
+task :default => :test

data/lib/test/unit/context.rb

@@ -0,0 +1,75 @@
+require "test/unit"
+require "test/unit/context/helpers"
+require "test/unit/context/version"
+
+module Test
+  module Unit
+    module Context
+
+      def context_name #:nodoc:
+        @context_name ||= ""
+        if superclass.respond_to?(:context_name)
+          return "#{superclass.context_name} #{@context_name}".gsub(/^\s+/, "")
+        end
+      end
+
+      def context_name=(val) #:nodoc:
+        @context_name = val
+      end
+
+      # Add a context to a set of tests.
+      # 
+      #   context "A new account" do
+      #     test "does not have users"
+      #       assert Account.new.users.empty?
+      #     end
+      #   end
+      # 
+      # The context name is prepended to the test name, so failures look like this:
+      # 
+      #   1) Failure:
+      #   test_a_new_account_does_not_have_users() [./test/test_accounts.rb:4]:
+      #   <false> is not true.
+      # 
+      # Contexts can also be nested like so:
+      # 
+      #   context "A new account" do
+      #     context "created from the web application" do
+      #       test "has web as its vendor" do
+      #         assert_equal "web", users(:web_user).vendor
+      #       end
+      #     end
+      #   end
+      #
+      def context(name, &block)
+        klass = Class.new(self)
+        klass.context_name = name
+        # NOTE: make sure by default we run "inherited" setup/teardown hooks
+        # unless context code does re-define the hook method e.g. `def setup` 
+        # instead of using the `setup do` or the setup method marker syntax :
+        klass.class_eval do
+          def setup; super; end
+          def cleanup; super; end
+          def teardown; super; end
+        end
+        klass.class_eval(&block)
+
+        #@@context_list << klass # make sure it's not GC-ed ?!
+        class_name = Helpers.to_class_name(name)
+        const_set("Test#{class_name}#{klass.object_id.abs}", klass)
+        klass
+      end
+
+      %w( contexts group ).each { |m| alias_method m, :context }
+      
+      #@@context_list = []
+      
+    end
+  end
+end
+
+Test::Unit::TestCase.extend Test::Unit::Context
+
+require "test/unit/context/shared"
+
+Test::Unit::TestCase.extend Test::Unit::Context::Shared

data/lib/test/unit/context/helpers.rb

@@ -0,0 +1,23 @@
+module Test::Unit::Context
+  module Helpers
+    
+    module_function
+    
+    # Replaces spaces and tabs with _ so we can use the string as a method name
+    # Also replace dangerous punctuation
+    def to_method_name(str)
+      str.downcase.gsub(/[\s:',\.~;!#=\(\)&]+/,'_')
+    end
+
+    # Borrowed from +camelize+ in ActiveSupport
+    def to_module_name(str)
+      to_method_name(str).gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+    end
+
+    # Borrowed from +camelize+ in ActiveSupport
+    def to_class_name(str)
+      to_method_name(str).gsub(/\/(.?)/) { "#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+    end
+    
+  end
+end

data/lib/test/unit/context/shared.rb

@@ -0,0 +1,96 @@
+module Test::Unit::Context
+  module Shared
+    
+    # Share behavior among different contexts.
+    # This creates a module (actually, a Module subclass) that is included 
+    # using the +use+ method (or one of its aliases) provided by context (or 
+    # +include+ if you know the module's constant name).
+    #
+    # ==== Examples
+    #   
+    #   shared "aasome-things" do
+    #     test "does some thing" do
+    #       # some-thing is awesome
+    #     end
+    #   end
+    #
+    #   like "aasome-things"
+    #   # or 
+    #   use "aasome-things"
+    #
+    #   share_as :client do
+    #     test "is a client to our server" do
+    #       # ...
+    #     end
+    #   end
+    #
+    #   like_a :client
+    #   # or 
+    #   uses "client"
+    #
+    def shared(name, &block)
+      if ! name.is_a?(String) && ! name.is_a?(Symbol)
+        raise ArgumentError, "use a String or Symbol as the name e.g. " + 
+                             "`shared #{name.to_s.inspect} do ...`"  
+      end
+      module_name = Helpers.to_module_name(name.to_s)
+      Object.const_set(module_name, Behavior.create(block))
+    end
+    
+    %w( share_as ).each { |m| alias_method m, :shared }
+    
+    # Pull in behavior shared by +shared+ or a module.  
+    #
+    # ==== Examples
+    #   
+    #   shared "awesome things" do
+    #     test "does some thing" do
+    #       # some-thing is awesome
+    #     end
+    #   end
+    #
+    #   like "awesome things"
+    #
+    #   module AwesomeThings
+    #     # ...
+    #   end
+    #
+    #   uses AwesomeThings
+    #
+    def like(shared_name)
+      case shared_name
+      when String
+        module_name = Helpers.to_module_name(shared_name)
+        include Object.const_get(module_name)
+      when Symbol
+        module_name = Helpers.to_module_name(shared_name.to_s)
+        include Object.const_get(module_name)
+      when Module, Behavior
+        include shared_name
+      else
+        raise ArgumentError, "pass a String or Symbol as the name e.g. " +
+                              "`like #{shared_name.to_s.inspect} do ...`"
+      end
+    end
+    
+    %w( like_a use uses ).each { |m| alias_method m, :like }
+    
+    class Behavior < Module
+
+      def self.create(block) # :nodoc:
+        self.new(block)
+      end
+
+      def initialize(block)
+        super()
+        @_block = block
+      end
+
+      def included(klass) # :nodoc:
+        klass.class_eval(&@_block) # @_block.call
+      end
+
+    end
+    
+  end
+end

data/lib/test/unit/context/version.rb

@@ -0,0 +1,7 @@
+module Test
+  module Unit
+    module Context
+      VERSION = "0.1.0"
+    end
+  end
+end

data/test-unit-context.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require 'test/unit/context/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "test-unit-context"
+  gem.version       = Test::Unit::Context::VERSION
+  gem.authors       = ["kares"]
+  gem.email         = ["self@kares.org"]
+  
+  gem.summary       = %q{Context for Test::Unit (2.x)}
+  gem.description   = %q{Makes Test::Unit::TestCases 'contextable' and thus much
+easier to read and write. If you've seen RSpec than it's the very same 'context 
+do ... end' re-invendet for Test::Unit. Inspired by gem 'context' that does the
+same for the 'old' Test::Unit 1.2.3 bundled with Ruby 1.8.x standard libraries.}
+  gem.homepage      = "http://github.com/kares/test-unit-context"
+
+  gem.require_paths = ["lib"]
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test}/*`.split("\n")
+  
+  gem.extra_rdoc_files = %w[ README.md LICENSE ]
+  
+  gem.add_dependency 'test-unit', '>= 2.4.0'
+  gem.add_development_dependency 'rake'
+end

data/test/test/unit/context/hooks_test.rb

@@ -0,0 +1,239 @@
+require File.expand_path('../../../test_helper', File.dirname(__FILE__))
+
+module Test::Unit::Context
+  class TestHooks < Test::Unit::TestCase
+    
+    class << self; alias_method :it, :test; end
+    
+    setup do
+      @inherited_before_each_var ||= 0
+      @inherited_before_each_var  += 1
+    end
+    
+    attr_reader :inherited_before_each_var
+
+    def setup
+      @inherited_before_each_var   ||= 0
+      @inherited_before_each_var_2 ||= 0
+      @inherited_before_each_var    += 2
+      @inherited_before_each_var_2  += 1
+    end
+
+    attr_reader :inherited_before_each_var_2
+    
+    def teardown
+      @inherited_after_each_var ||= 0
+      @inherited_after_each_var  += 1
+    end
+
+    attr_reader :inherited_after_each_var
+    
+    startup do
+      @inherited_before_all_var ||= 0
+      @inherited_before_all_var  += 1
+    end
+
+    attr_reader :inherited_before_all_var
+    
+    shutdown do
+      @inherited_after_all_var ||= 0
+      @inherited_after_all_var  += 1
+    end
+  
+    attr_reader :inherited_after_all_var
+    
+    SAMPLE_TEST = context "hooks" do
+
+      setup do
+        @inherited_before_each_var ||= 0
+        @inherited_before_each_var  += 4
+      end
+
+      teardown do
+        @after_each_var ||= 0
+        @after_each_var  += 1
+      end
+
+      attr_reader :after_each_var
+      
+      teardown :a_method
+
+      test "foo" do
+        assert :foo
+      end
+      
+    end
+
+    setup
+    def a_setup
+      @superclass_before_each_var ||= 0
+      @superclass_before_each_var  += 1
+    end
+
+    attr_reader :superclass_before_each_var
+    
+    teardown
+    def a_teardown
+      @superclass_after_each_var ||= 0
+      @superclass_after_each_var  += 1
+    end
+
+    attr_reader :superclass_after_each_var
+    
+    context "with (inherited) setup/teadown hooks" do
+
+      it "runs superclass before callbacks in order" do
+        assert_equal 1, @test.superclass_before_each_var
+      end
+
+      it "runs inherited before callbacks in order" do
+        assert_equal 7, @test.inherited_before_each_var
+      end
+
+      it "runs before callbacks in order" do
+        assert_equal 1, @test.inherited_before_each_var_2
+      end
+
+      it "runs superclass after callbacks" do
+        assert_equal 1, @test.superclass_after_each_var
+      end
+
+      it "runs inherited after callbacks" do
+        assert_equal 1, @test.inherited_after_each_var
+      end
+
+      it "runs after callbacks" do
+        assert_equal 1, @test.after_each_var
+      end
+
+      it "runs after callbacks specified with method names, instead of blocks" do
+        assert_equal "a method ran", @test.ivar
+      end
+      
+      setup do
+        @result = Test::Unit::TestResult.new
+        @test = SAMPLE_TEST.new("test: hooks foo")
+        @test.run(@result) { |inherited_after_each_var, v| }
+      end
+      
+    end
+
+    context "with redefined setup/teadown methods" do
+
+      SAMPLE_TEST.class_eval do
+        OLD_SETUP = instance_method(:setup)
+        OLD_TEARDOWN = instance_method(:teardown)
+      end
+      
+      setup do
+        SAMPLE_TEST.class_eval do
+          def setup
+            @superclass_before_each_var ||= 0
+            @inherited_before_each_var_2 ||= 9
+          end
+          def teardown
+            @superclass_after_each_var ||= 0
+          end
+        end
+        
+        @result = Test::Unit::TestResult.new
+        @test = SAMPLE_TEST.new("test: hooks foo")
+        @test.run(@result) { |inherited_after_each_var, v| }
+      end
+      
+      teardown do
+        SAMPLE_TEST.class_eval do
+          remove_method :setup
+          remove_method :teardown
+          
+          define_method(:setup, OLD_SETUP)
+          define_method(:teardown, OLD_TEARDOWN)
+        end
+      end
+      
+      it "runs superclass before callbacks" do
+        assert_equal 1, @test.superclass_before_each_var
+      end
+
+      it "runs superclass after callbacks" do
+        assert_equal 1, @test.superclass_after_each_var
+      end
+      
+      it "does not run inherited (re-defined) setup method" do
+        assert_equal 9, @test.inherited_before_each_var_2
+      end
+      
+      it "runs inherited before callbacks (except previous setup method)" do
+        assert_equal 5, @test.inherited_before_each_var
+      end
+      
+    end
+    
+    # test that we aren't stomping on defined setup method
+    context "with setup/teardown methods" do
+      
+      setup
+      def custom_setup
+        @result = Test::Unit::TestResult.new
+        @test = SAMPLE_TEST.new("test: hooks foo")
+
+        @test.class.setup do
+          @one = 1
+        end
+
+        @test.class.teardown do
+          @two = 10
+        end
+
+        @test.run(@result) { |inherited_after_each_var, v| }
+      end
+      
+      SAMPLE_TEST.class_eval { attr_reader :one, :two }
+      
+      it "runs setup method block a la Shoulda" do
+        assert_equal 1, @test.one
+      end
+
+      it "runs setup method block and regular callbacks" do
+        assert_equal 7, @test.inherited_before_each_var
+      end
+
+      it "runs teardown method block a la Shoulda" do
+        assert_equal 10, @test.two
+      end
+
+      it "runs teardown method block and regular callbacks" do
+        assert_equal 1, @test.after_each_var
+      end
+      
+    end
+
+    def self.startup
+      @superclass_before_all_var ||= 0
+      @superclass_before_all_var  += 1
+    end
+    
+    def self.shutdown
+      @superclass_after_all_var ||= 0
+      @superclass_after_all_var  += 1
+    end
+    
+    context "To be compatible with rails' expectations" do
+      setup :a_method
+
+      test "should accept a symbol for an argument to setup and run that method at setup time" do
+        assert_equal "a method ran", @ivar
+      end
+    end
+
+    protected
+    
+    attr_reader :ivar
+    
+    def a_method
+      @ivar = "a method ran"
+    end
+    
+  end
+  
+end

data/test/test/unit/context/shared_test.rb

@@ -0,0 +1,139 @@
+require File.expand_path('../../../test_helper', File.dirname(__FILE__))
+
+module Test::Unit::Context
+  class SharedTest < Test::Unit::TestCase
+    
+    def test_shared_aliases
+      #%w(shared_behavior share_as share_behavior_as shared_examples_for).each do |method_alias|
+        #assert self.class.respond_to?(method_alias.to_sym)
+      #end
+      assert self.class.respond_to?(:shared)
+      assert self.class.respond_to?(:share_as)
+    end
+
+    def test_like_aliases
+      #%w(uses it_should_behave_like behaves_like uses_examples_from).each do |method_alias|
+        #assert self.class.respond_to?(method_alias.to_sym)
+      #end
+      assert self.class.respond_to? :like
+      assert self.class.respond_to? :use
+      assert self.class.respond_to? :uses
+    end
+
+    class << self; alias_method :it, :test; end
+    
+    context "A shared group" do
+      context "creates a module" do
+        test "based on a string name" do
+          self.class.shared "things and fun" do
+          end
+
+          assert Object.const_get(:ThingsAndFun)
+          assert_equal Shared::Behavior, Object.const_get(:ThingsAndFun).class
+        end
+
+        it "based on a symbol name" do
+          self.class.shared :fun_and_games do
+          end
+
+          assert Object.const_get(:FunAndGames)
+          assert_equal Shared::Behavior, Object.const_get(:FunAndGames).class
+        end
+
+        it "unless the name is not a String or Symbol" do
+          assert_raise ArgumentError do
+            self.class.shared StandardError do
+            end
+          end
+        end
+      end
+
+      context "should be locatable" do      
+        shared "hello sir" do
+          def amazing!
+            puts "back off!"
+          end
+        end
+
+        it "by a symbol" do
+          assert_nothing_raised do
+            self.class.use :hello_sir
+          end
+        end
+
+        shared "hello madam" do
+          def fantastic!
+            puts "you know me!"
+          end
+        end
+
+        it "by a string" do
+          assert_nothing_raised do
+            self.class.use "hello madam"
+          end
+        end
+
+        shared "hi dog" do
+          def stupendous!
+            puts "hoo hah!"
+          end
+        end
+
+        it "by direct reference" do
+          assert_nothing_raised do
+            self.class.use HiDog
+          end
+        end
+      end
+
+      context "should include its shared behavior" do
+        shared "Athos" do
+          test "en_garde" do
+            true
+          end
+        end
+
+        test "no en_garde" do
+          assert_raise NoMethodError do 
+            send("test: en_garde")
+          end
+        end
+        
+        context 'use by a symbol' do
+          
+          like :athos
+          
+          test "athos" do
+            assert_nothing_raised do 
+              send("test: en_garde")
+            end
+          end
+          
+        end
+
+        shared "Porthos" do
+          def parry!
+            true
+          end
+        end
+
+        test "by a string" do
+          self.class.use "Porthos"
+          assert parry!
+        end
+
+        shared "Aramis" do
+          def lunge!
+            true
+          end
+        end
+
+        test "by direct reference" do
+          self.class.uses Aramis
+          assert lunge!
+        end
+        
+      end
+    end
+  end
+end

data/test/test/unit/context_test.rb

@@ -0,0 +1,71 @@
+require File.expand_path('../../test_helper', File.dirname(__FILE__))
+
+module Test::Unit
+  class TestContext < Test::Unit::TestCase
+    
+    def test_test_without_context
+      assert true
+    end
+
+    test "another test without a context" do
+      assert true
+    end
+    
+    def test_context_aliases
+      assert self.class.respond_to? :context
+      assert self.class.respond_to? :contexts
+    end
+
+    context "A new context" do
+      
+      context "when not nested" do
+        setup do
+          @context = 
+            Class.new(Test::Unit::TestCase).
+              context("When testing") do
+                def test_this_thing
+                  true
+                end
+              end
+        end
+
+        test "should set the context name" do
+          assert_equal "When testing", @context.context_name
+        end
+
+        test "should be a Test::Unit::TestCase" do
+          assert @context.ancestors.include?(Test::Unit::TestCase)
+        end
+        
+      end
+
+      context "when nested" do
+        
+        setup do
+          @context = self.class.context("and we're testing") do
+            def self.nested
+              @nested
+            end
+
+            @nested = context "should be nested" do
+              def test_this_thing
+                true
+              end
+            end
+          end
+        end
+
+        test "should set a nested context's name" do
+          assert_equal "A new context when nested and we're testing should be nested", @context.nested.context_name
+        end
+
+        test "should also be a Test::Unit::TestCase" do
+          assert @context.nested.ancestors.include?(Test::Unit::TestCase)
+        end
+        
+      end
+    end
+    
+  end
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,8 @@
+begin
+  require 'test/unit/version'
+rescue LoadError => e
+  require('rubygems') && retry
+  fail "`bundle install` to install Test::Unit 2.x (#{e.inspect})"
+end
+$LOAD_PATH.unshift File.expand_path('../lib', File.dirname(__FILE__))
+require 'test/unit/context'

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification 
+name: test-unit-context
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+  - kares
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-10-10 00:00:00 Z
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: test-unit
+    prerelease: false
+    requirement: &id001 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: 2.4.0
+    type: :runtime
+    version_requirements: *id001
+  - !ruby/object:Gem::Dependency 
+    name: rake
+    prerelease: false
+    requirement: &id002 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    type: :development
+    version_requirements: *id002
+description: |-
+  Makes Test::Unit::TestCases 'contextable' and thus much
+  easier to read and write. If you've seen RSpec than it's the very same 'context 
+  do ... end' re-invendet for Test::Unit. Inspired by gem 'context' that does the
+  same for the 'old' Test::Unit 1.2.3 bundled with Ruby 1.8.x standard libraries.
+email: 
+  - self@kares.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+  - README.md
+  - LICENSE
+files: 
+  - .gitignore
+  - Gemfile
+  - LICENSE
+  - README.md
+  - Rakefile
+  - lib/test/unit/context.rb
+  - lib/test/unit/context/helpers.rb
+  - lib/test/unit/context/shared.rb
+  - lib/test/unit/context/version.rb
+  - test-unit-context.gemspec
+  - test/test/unit/context/hooks_test.rb
+  - test/test/unit/context/shared_test.rb
+  - test/test/unit/context_test.rb
+  - test/test_helper.rb
+homepage: http://github.com/kares/test-unit-context
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Context for Test::Unit (2.x)
+test_files: []
+