test-unit-context 0.1.0 → 0.2.0

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.3
+  - jruby-18mode
+  - jruby-19mode

data/README.md

@@ -1,5 +1,7 @@
 # Test::Unit::Context
 
+[![Build Status][0]](http://travis-ci.org/kares/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**. 
@@ -96,3 +98,5 @@ end
 
 Copyright (c) 2012 [Karol Bucek](https://github.com/kares). 
 See LICENSE (http://www.apache.org/licenses/LICENSE-2.0) for details.
+
+[0]: https://secure.travis-ci.org/kares/test-unit-context.png

data/lib/test/unit/context.rb

@@ -1,75 +1,26 @@
-require "test/unit"
-require "test/unit/context/helpers"
-require "test/unit/context/version"
+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 ||= ""
+      
+      def context_name
         if superclass.respond_to?(:context_name)
-          return "#{superclass.context_name} #{@context_name}".gsub(/^\s+/, "")
+          "#{superclass.context_name} #{@context_name}".gsub(/^\s+/, "")
+        else
+          @context_name
         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 = []
+      def context_name=(name); @context_name=name; end
       
     end
   end
 end
 
-Test::Unit::TestCase.extend Test::Unit::Context
-
-require "test/unit/context/shared"
-
-Test::Unit::TestCase.extend Test::Unit::Context::Shared
+require 'test/unit/context/context'
+Test::Unit::TestCase.extend Test::Unit::Context::Context
+require 'test/unit/context/shared'
+Test::Unit::TestCase.extend Test::Unit::Context::Shared

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

@@ -0,0 +1,85 @@
+require 'time'
+
+module Test::Unit::Context
+  module Context
+
+    # 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
+    #
+    # Context should have unique names within a given scope, otherwise they 
+    # end-up being merged as if it where one single context declaration. 
+    # Anonymous (un-named) contexts are supported as well - contrary they 
+    # never get merged (a unique name is generated for each such context).
+    #
+    def context(name = nil, &block)
+      name ||= Helpers.generate_uuid
+      # context "created with defaults" ... 'ContextCreatedWithDefaults'
+      class_name = Helpers.to_const_name(name.to_s, 'Context')
+      if const_defined?(class_name)
+        klass = const_get(class_name)
+        if ( klass.superclass == self rescue nil )
+          warn "duplicate context definition with the name #{name.inspect} " << 
+                "found at #{caller.first} it is going to be merged with " << 
+                "the previous context definition"
+        else
+          raise "could not create a context with the name #{name.inspect} " << 
+                "as a constant #{class_name} is already defined and is not " << 
+                "another context definition"
+        end
+      else
+        klass = Class.new(self)
+        klass.extend Test::Unit::Context
+        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
+        const_set(class_name, klass)
+      end
+      context_definitions << klass
+      klass.class_eval(&block)
+      klass
+    end
+
+    %w( contexts group ).each { |m| alias_method m, :context }
+    
+    def context_definitions(nested = false)
+      @_context_definitions ||= []
+      if nested
+        contexts = @_context_definitions.dup
+        @_context_definitions.each do |context|
+          contexts.push *context.context_definitions(nested)
+        end
+        contexts
+      else
+        @_context_definitions
+      end
+    end
+
+  end
+end

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

@@ -3,20 +3,18 @@ module Test::Unit::Context
     
     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:',\.~;!#=\(\)&]+/,'_')
+    def to_const_name(str, prefix = nil)
+      name = prefix ? str.dup : str.lstrip
+      name.gsub!(/[\s:',\.~;!#=\(\)&]+/, '_')
+      name.gsub!(/\/(.?)/) { $1.upcase }
+      name.gsub!(/(?:^|_)(.)/) { $1.upcase }
+      prefix ? "#{prefix}#{name}" : name
     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 }
+    
+    def generate_uuid
+      uuid = [ (Time.now.to_f * 1000).to_i % 10 ]
+      15.times { uuid << rand(16).to_s(16) }
+      uuid.join
     end
     
   end

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

@@ -33,8 +33,30 @@ module Test::Unit::Context
         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))
+      const_name = Helpers.to_const_name(name.to_s)
+      if Behavior.const_defined?(const_name)
+        const = Behavior.const_get(const_name)
+        if Behavior === const
+          raise "duplicate shared definition with the name #{name.inspect} " <<
+                 "found at #{caller.first} please provide an unique name"
+        else
+          raise "could not create a shared definition with the name " << 
+                "#{name.inspect} as a constant #{Behavior.name}::#{const_name} " <<
+                "already exists"
+        end
+      else
+        behavior = Behavior.new(name, block)
+        Behavior.const_set(const_name, behavior)
+        # expose at current top-level test-case as a constant as well :
+        test_case = self
+        while test_case.is_a?(Test::Unit::Context)
+          test_case = test_case.superclass
+        end
+        unless test_case.const_defined?(const_name)
+          test_case.const_set(const_name, behavior)
+        end
+        behavior
+      end
     end
     
     %w( share_as ).each { |m| alias_method m, :shared }
@@ -59,13 +81,20 @@ module Test::Unit::Context
     #
     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
+      when String, Symbol
+        const_name = Helpers.to_const_name(shared_name.to_s)
+        if Behavior.const_defined?(const_name)
+          const = Behavior.const_get(const_name)
+          if Behavior === const
+            include const
+          else
+            raise "#{shared_name.inspect} does not resolve into a shared " << 
+                   "behavior instance but to a #{const.inspect}"
+          end
+        else
+          raise "shared behavior with name #{shared_name.inspect} not defined"
+        end
+      when Behavior, Module
         include shared_name
       else
         raise ArgumentError, "pass a String or Symbol as the name e.g. " +
@@ -75,14 +104,25 @@ module Test::Unit::Context
     
     %w( like_a use uses ).each { |m| alias_method m, :like }
     
-    class Behavior < Module
-
-      def self.create(block) # :nodoc:
-        self.new(block)
+    # Returns all available shared definitions.
+    def shared_definitions
+      shareds = []
+      constants.each do |name|
+        const = const_get(name)
+        if const.is_a?(Behavior)
+          shareds << const
+        end
       end
-
-      def initialize(block)
+      shareds
+    end
+    
+    class Behavior < Module
+      
+      attr_reader :shared_name
+      
+      def initialize(name, block)
         super()
+        @shared_name = name
         @_block = block
       end
 

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

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

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

@@ -24,28 +24,30 @@ module Test::Unit::Context
     
     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
+          assert Shared::Behavior.const_defined?(:ThingsAndFun)
+          assert_instance_of Shared::Behavior, Shared::Behavior.const_get(:ThingsAndFun)
         end
 
-        it "based on a symbol name" do
+        test "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
+          assert Shared::Behavior.const_defined?(:FunAndGames)
+          assert_instance_of Shared::Behavior, Shared::Behavior.const_get(:FunAndGames)
         end
 
-        it "unless the name is not a String or Symbol" do
+        test "unless the name is not a String or Symbol" do
           assert_raise ArgumentError do
-            self.class.shared StandardError do
+            self.class.shared 42 do
             end
           end
         end
+        
       end
 
       context "should be locatable" do      
@@ -84,6 +86,12 @@ module Test::Unit::Context
             self.class.use HiDog
           end
         end
+        
+        it "by behavior reference" do
+          assert_nothing_raised do
+            self.class.use Shared::Behavior::HiDog
+          end
+        end
       end
 
       context "should include its shared behavior" do
@@ -134,6 +142,18 @@ module Test::Unit::Context
         end
         
       end
+      
+      test "locates all shared behaviors with their names" do
+        assert_not_nil shareds = self.class.shared_definitions
+        assert shareds.size >= 4, shareds.inspect
+        assert_include shareds, Test::Unit::Context::Shared::Behavior::HiDog
+        assert_equal 'hi dog', Test::Unit::Context::Shared::Behavior::HiDog.shared_name
+        [ :Athos, :Porthos, :Aramis ].each do |name|
+          assert_include shareds, behavior = self.class.const_get(name)
+          assert_equal name.to_s, behavior.shared_name
+        end
+      end
+      
     end
   end
 end

data/test/test/unit/context_test.rb

@@ -16,56 +16,173 @@ module Test::Unit
       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
+    class Default < Test::Unit::TestCase
+      CONTEXT = context "When testing" do
+        def test_this_thing
+          true
         end
+      end
+      context "More testing" do
+        # @todo implement more tests here ...
+      end
+    end
 
-        test "should set the context name" do
-          assert_equal "When testing", @context.context_name
-        end
+    setup do
+      @default_context = Default::CONTEXT
+    end
+    
+    test "[default context] sets the context name" do
+      assert_equal "When testing", @default_context.context_name
+    end
 
-        test "should be a Test::Unit::TestCase" do
-          assert @context.ancestors.include?(Test::Unit::TestCase)
+    test "[default context] is a Test::Unit::TestCase" do
+      assert @default_context.ancestors.include?(Test::Unit::TestCase)
+    end
+
+    test "[default context] is defived from the test class" do
+      assert_equal Default, @default_context.superclass
+    end
+    
+    test "[default context] reports among test case's context defs" do
+      assert Default.respond_to?(:context_definitions)
+      assert_include Default.context_definitions, @default_context
+      assert_equal 2, Default.context_definitions.size
+    end
+    
+    test "has a (context name derived) class name" do
+      namespace = 'Test::Unit::TestContext::Default::'
+      assert_equal "#{namespace}ContextWhenTesting", @default_context.name
+    end
+
+    class Anonymous < Test::Unit::TestCase
+      CONTEXT = context do
+        def test_some_thing
+          true
         end
-        
       end
+      context do
+        test 'another_thing' do
+        end
+      end
+      context do
+        #
+      end
+    end
+    
+    setup do
+      @anonymous_context = Anonymous::CONTEXT
+    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
+    test "[anonymous context] has a generated context name" do
+      assert_not_nil @anonymous_context.name
+    end
+    
+    test "[anonymous context] is defived from the test class" do
+      assert_equal Anonymous, @anonymous_context.superclass
+    end
+    
+    test "[anonymous context] reports among test case's context defs" do
+      assert Anonymous.respond_to?(:context_definitions)
+      assert_include Anonymous.context_definitions, @anonymous_context
+      assert_equal 3, Anonymous.context_definitions.size
+      assert_equal 3, Anonymous.context_definitions(true).size
+    end
+    
+    test "[anonymous context] has a (context name derived) class name" do
+      namespace = 'Test::Unit::TestContext::Anonymous::'
+      context_name = @anonymous_context.context_name
+      assert_equal "#{namespace}Context#{context_name}", @anonymous_context.name
+    end
+    
+    class Nested < Test::Unit::TestCase
+      CONTEXT = context "and we're testing" do
+        @nested = context "should be nested" do
+          def test_a_thing
+            true
           end
         end
+        def self.nested; @nested; end
+      end
+    end
+
+    setup do
+      @parent_context = Nested::CONTEXT
+      @nested_context = Nested::CONTEXT.nested
+    end
+    
+    test "[nested context] sets a nested context name" do
+      assert_equal "and we're testing should be nested", @nested_context.context_name
+    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
+    test "[nested context] is also a Test::Unit::TestCase" do
+      assert @nested_context.ancestors.include?(Test::Unit::TestCase)
+    end
+
+    test "[nested context] is defived from the prev context class" do
+      assert_equal @parent_context, @nested_context.superclass
+    end
+    
+    test "[nested context] reports context defs correctly" do
+      assert Nested.respond_to?(:context_definitions)
+      assert_equal 1, Nested.context_definitions.size
+      assert_equal 1, @parent_context.context_definitions.size
+      assert_equal 0, @nested_context.context_definitions.size
+      assert_equal 2, Nested.context_definitions(true).size
+    end
+    
+    test "[nested context] has a (context name derived) class name" do
+      namespace = 'Test::Unit::TestContext::Nested::'
+      assert_equal "#{namespace}ContextAndWeReTesting::ContextShouldBeNested", 
+                    @nested_context.name
+    end
+    
+    class Redefined < Test::Unit::TestCase
+      CONTEXT = context 42 do
+        def test_everything
+          true
         end
+      end
+      @@warns = nil
+      def self.warn(message)
+        ( @@warns ||= [] ) << message
+        super
+      end
+      def self.warns; @@warns; end
+      def self.reset_warns; @@warns = nil; end
+    end
+
+    setup do
+      @redefined_context = Redefined::CONTEXT
+    end
+    
+    test "[redefined context] sets the context name" do
+      assert_equal 42, @redefined_context.context_name
+    end
 
-        test "should also be a Test::Unit::TestCase" do
-          assert @context.nested.ancestors.include?(Test::Unit::TestCase)
+    test "[redefined context] warns when same context name used" do
+      assert_nil Redefined.warns
+      class Redefined
+        context 42 do
+          def test_something_else
+            assert true
+          end
+        end
+      end
+      assert_not_nil Redefined.warns
+      assert_equal 2, @redefined_context.instance_methods(false).grep(/test/).size
+      
+      Redefined.reset_warns
+      
+      assert_nil Redefined.warns
+      class Redefined
+        context '42' do # same class-name
+          def test_a_little_thing
+          end
         end
-        
       end
+      assert_not_nil Redefined.warns
+      assert_equal 3, @redefined_context.instance_methods(false).grep(/test/).size
     end
     
   end
-  
 end

metadata

@@ -1,94 +1,98 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: test-unit-context
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 0.2.0
   prerelease: 
-  version: 0.1.0
 platform: ruby
-authors: 
-  - kares
+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
+date: 2012-10-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.4.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! "Makes Test::Unit::TestCases 'contextable' and thus much\neasier to
+  read and write. If you've seen RSpec than it's the very same 'context \ndo ... end'
+  re-invendet for Test::Unit. Inspired by gem 'context' that does the\nsame 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
+extra_rdoc_files:
+- README.md
+- LICENSE
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/test/unit/context.rb
+- lib/test/unit/context/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 
+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 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.8.15
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Context for Test::Unit (2.x)
 test_files: []
-