shared_should 0.6.6 → 0.7.0

data/README.md

@@ -111,7 +111,7 @@ Some rules:
 * You can redefine your shares by using the same name. These shares will only be available in in the current and descendant contexts.
 * Shares defined at the root (on your TestCase) are available in all contexts.
 
-### Initialization Block
+### Initialization Blocks
 
 The shared invocation accepts an initialization block by chaining <tt>with</tt> (or its alias <tt>when</tt>) followed by a block. This block can be used to create or modify instance variables used by the shared functionality. It always executes before the shared functionality.
 
@@ -200,6 +200,39 @@ The shared functions also accept multiple parameters when the parameterization b
         end
     end
 
+### Chaining shared setups with <tt>with_setup</tt>
+
+Shared setup can be chained for use with shared shoulds and shared contexts.
+
+    context "Book" do
+        share_setup "for a rentable book" do
+            @book = Book.new(:quantity => 1, :price => 10_00, :rentable => true, :purchasable => false)
+        end
+
+        share_should "be available for checkout" { assert @book.available_for_checkout? }
+        
+        use_should("be available for checkout").with_setup("for a rentable book")
+    end
+
+And can be parameterized using a <tt>given</tt> clause.
+
+    context "Book" do
+        share_setup "for an in-stock book" do |rentable|
+            @book = Book.new(:quantity => 1, :price => 10_00, :rentable => rentable, :purchasable => false)
+        end
+
+        share_should "be available for checkout" { assert @book.available_for_checkout? }
+    
+        use_should("be available for checkout").with_setup("for an in-stock book").given("the book is rentable") { true }
+    end
+
+Multiple shared setups can then be combined with an initialization block.
+
+    use_should("successfully checkout shopping cart").
+        with_setup("for an empty shopping cart").
+        with_setup("for a rentable book").
+        with("a book in shopping cart") { @shopping_cart.add_book(@book) }
+
 ### Creating a Library of Shared Functionality
 
 The shared functions can also be re-usable across multiple test cases.

data/VERSION

@@ -1 +1 @@
-0.6.6
+0.7.0

data/lib/shared_should.rb

@@ -1,20 +1,5 @@
 require 'shoulda'
 
-class Shoulda::Context
-  alias :method_missing_without_shared_method_check :method_missing
-  def method_missing(method, *args, &blk)
-    current_context = self
-    while current_context.kind_of?(Shoulda::Context) || current_context < Test::Unit::TestCase do
-      if Test::Unit::TestCase.shared_context_block_owner(current_context).shared_context_blocks[method.to_s]
-        return current_context.send(method, args[0], self, &blk)
-      end
-      break unless current_context.kind_of?(Shoulda::Context)
-      current_context = current_context.parent
-    end
-    method_missing_without_shared_method_check(method, *args, &blk)
-  end
-end
-
 class Test::Unit::TestCase
   attr_accessor :shared_value
   @@shared_proxies_executed = {}
@@ -108,20 +93,20 @@ module Shoulda::SharedContext
     end
   
     def use_should(shared_name)
-      shared_proxy = Shoulda::SharedProxy.new(self, shared_name)
+      shared_proxy = Shoulda::SharedProxy.new(self, :should, shared_name)
       shared_proxies << shared_proxy
       return shared_proxy
     end
     
     def use_context(shared_name)
-      shared_proxy = Shoulda::SharedProxy.new(self, shared_name)
+      shared_proxy = Shoulda::SharedProxy.new(self, :context, shared_name)
       shared_proxies << shared_proxy
       return shared_proxy
     end
     
     def use_setup(shared_name)
-      shared_proxy = Shoulda::SharedProxy.new(self, shared_name)
-      shared_setup_block = find_shared_setup_block(shared_name)
+      shared_proxy = Shoulda::SharedProxy.new(self, :setup, shared_name)
+      shared_setup_block = find_shared_block(:setup, shared_name)
       setup do
         shared_proxy.execute_and_set_shared_value(self)
         call_block_with_shared_value(shared_setup_block)
@@ -163,11 +148,6 @@ module Shoulda::SharedContext
       end
     end
   
-    # deprecated
-    def shared_context_should(shared_context_name, &shared_context_block)
-      share_context(shared_context_name, &shared_context_block)
-    end
-
     def share_context(shared_context_name, &shared_context_block)
       wrapping_shared_context_block = Proc.new do
         context shared_context_name do
@@ -175,12 +155,7 @@ module Shoulda::SharedContext
         end
       end
 
-      do_shared_context(shared_context_name, shared_context_for_block(shared_context_block), &wrapping_shared_context_block)
-    end
-
-    # deprecated
-    def shared_should(shared_should_name, &shared_should_block)
-      share_should(shared_should_name, &shared_should_block)
+      Test::Unit::TestCase.shared_context_block_owner(shared_context_for_block(shared_context_block)).shared_context_blocks[shared_context_name] = wrapping_shared_context_block
     end
 
     def share_should(shared_should_name, &shared_should_block)
@@ -190,16 +165,7 @@ module Shoulda::SharedContext
         end
       end
 
-      do_shared_context(shared_should_name, shared_context_for_block(shared_should_block), &shared_context_block)
-    end
-
-    # deprecated
-    def shared_setup(shared_name, &setup_block)
-      shared_setup_block = Proc.new do
-        call_block_with_shared_value(setup_block)
-      end
-
-      do_shared_setup(shared_name, shared_context_for_block(setup_block), &shared_setup_block)
+      Test::Unit::TestCase.shared_context_block_owner(shared_context_for_block(shared_should_block)).shared_should_blocks[shared_should_name] = shared_context_block
     end
 
     def share_setup(shared_name, &setup_block)
@@ -219,16 +185,25 @@ module Shoulda::SharedContext
        @shared_setup_blocks ||= {}
     end
 
-    private
+    def find_shared_block(share_type, shared_name)
+      current_context = self
+      while current_context.kind_of?(Shoulda::Context) || current_context < Test::Unit::TestCase do
+        if shared_block = Test::Unit::TestCase.shared_context_block_owner(current_context).send("shared_#{share_type}_blocks")[shared_name]
+          return shared_block
+        end
+        raise "Unable to find share_#{share_type}('#{shared_name}')" if current_context.kind_of?(Class)
+        break unless current_context.kind_of?(Shoulda::Context)
+        current_context = current_context.parent
+      end
+      raise "Unable to find share_#{share_type}('#{shared_name}')"
+    end
+    
+  private
 
     def shared_context_for_block(shared_block)
       eval("self", shared_block.binding)
     end
 
-    def do_shared_context(shared_context_name, destination_context, &shared_context_block)
-      do_shared_helper(shared_context_name, destination_context, :should, :merge_shared_context, &shared_context_block)
-    end
-
     def merge_shared_context(shared_context_block, caller_context, name, initialization_block)
       name = '' if name.nil?
 
@@ -268,37 +243,6 @@ module Shoulda::SharedContext
       end
     end
 
-    def do_shared_helper(shared_name, destination_context, method_prefix, merge_method, &shared_setup_block)
-      method_name = shared_method_name(method_prefix, shared_name)
-      Test::Unit::TestCase.shared_context_block_owner(destination_context).shared_context_blocks[method_name] = shared_setup_block
-
-      # Ruby 1.8 workaround for define_method with a block
-      # http://coderrr.wordpress.com/2008/10/29/using-define_method-with-blocks-in-ruby-18/
-      eval <<-EOM
-        def destination_context.#{method_name}(name = nil, context = self, &setup_block)
-          #{merge_method}(Test::Unit::TestCase.shared_context_block_owner(self).shared_context_blocks['#{method_name}'], context, name, block_given? ? setup_block : nil)
-        end
-      EOM
-    end
-
-    def shared_method_name(method_prefix, context_name)
-      "#{method_prefix}_#{context_name.downcase.gsub(' ', '_').gsub(/[^_A-Za-z0-9]/, '')}"
-    end
-
-  private
-  
-    def find_shared_setup_block(shared_name)
-      current_context = self
-      while current_context.kind_of?(Shoulda::Context) || current_context < Test::Unit::TestCase do
-        if shared_setup_block = Test::Unit::TestCase.shared_context_block_owner(current_context).shared_setup_blocks[shared_name]
-          return shared_setup_block
-        end
-        raise "Unable to find share_setup('#{shared_name}')" if current_context.kind_of?(Class)
-        break unless current_context.kind_of?(Shoulda::Context)
-        current_context = current_context.parent
-      end
-      raise "Unable to find share_setup('#{shared_name}')"
-    end
   end
 end
 
@@ -312,10 +256,11 @@ end
 
 
 class Shoulda::SharedProxy
-  attr_accessor :shared_name, :description, :block_configs, :context
+  attr_accessor :shared_name, :share_type, :description, :block_configs, :context
   
-  def initialize(context, shared_name)
+  def initialize(context, share_type, shared_name)
     self.context = context
+    self.share_type = share_type
     self.shared_name = shared_name
     self.block_configs = []
   end
@@ -334,13 +279,19 @@ class Shoulda::SharedProxy
   end
   
   def with_setup(description)
-    initialization_block = context.send(:find_shared_setup_block, description)
+    initialization_block = context.find_shared_block(:setup, description)
     add_proxy_block(:with_setup, "with setup", description, :disable_and => true, &initialization_block)
   end
   
   def execute
-    method_name = context.send(:shared_method_name, :should, shared_name)
-    context.send(method_name, description, &initialization_block)
+    raise "execute cannot be called for share_setup" if share_type == :setup
+    shared_proxy = self
+    context.context description do
+      setup do
+        shared_proxy.execute_and_set_shared_value(self)
+      end
+      shared_proxy.context.find_shared_block(shared_proxy.share_type, shared_proxy.shared_name).bind(self).call
+    end
   end
   
   def execute_and_set_shared_value(test_context)
@@ -358,8 +309,6 @@ class Shoulda::SharedProxy
           call_block_with_shared_value(block) if block
         end
       end.last
-      # # TODO: needs shared_value
-      # blocks.collect {|block| block.bind(self).call if block}.last
     end
   end
   

data/shared_should.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{shared_should}
-  s.version = "0.6.6"
+  s.version = "0.7.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Michael Pearce"]

data/test/test_shared_should.rb

@@ -102,57 +102,6 @@ class TestSharedShould < Test::Unit::TestCase
     end
   end
   
-  context ".shared_context_should" do
-    context "without params" do
-      setup do
-        @value = true
-      end
-      
-      shared_context_should "be valid" do
-        setup do
-          @context_value = true
-        end
-        
-        should "have true value" do
-          assert @value
-        end
-        
-        should "call setup in shared context" do
-          assert @context_value
-        end
-      end
-      
-      should_be_valid
-    end
-    
-    context "with params" do
-      setup do
-        @value = true
-      end
-      
-      shared_context_should "be valid for specified value" do
-        setup do |value|
-          @expected_value = value
-          @context_value = true
-        end
-        
-        should "have specified value" do |value|
-          assert_equal value, @value
-        end
-        
-        should "setup @expected_value" do |value|
-          assert_equal value, @expected_value
-        end
-        
-        should "call setup in shared context" do
-          assert @context_value
-        end
-      end
-      
-      should_be_valid_for_specified_value { true }
-    end
-  end
-  
   context ".share_should" do
     context "without params" do
       share_should "be a true value" do
@@ -199,70 +148,6 @@ class TestSharedShould < Test::Unit::TestCase
     end
   end
   
-  context ".shared_should" do
-    context "without params" do
-      setup do
-        @value = true
-      end
-      
-      shared_should "have true value" do
-        assert @value
-      end
-      
-      should_have_true_value
-    end
-    
-    context "with params" do
-      setup do
-        @value = true
-      end
-      
-      shared_should "have specified value" do |value|
-        assert_equal value, @value
-      end
-      
-      should_have_specified_value { true }
-    end
-  end
-  
-  context ".shared_setup" do
-    context "without params" do
-      shared_setup "for value" do
-        @value = true
-      end
-  
-      context "with shared setup value" do
-        setup do
-          @value = false
-        end
-  
-        setup_for_value
-  
-        should "have a true value from shared setup" do
-          assert @value
-        end
-      end
-    end
-    
-    context "with params" do
-      shared_setup "for value" do |value|
-        @value = value
-      end
-      
-      context "with shared setup value" do
-        setup do
-          @value = false
-        end
-      
-        setup_for_value("with true") { true }
-      
-        should "have a true value from shared setup" do
-          assert @value
-        end
-      end
-    end
-  end
-  
   context ".share_setup" do
     context "without params" do
       context "without initialization block" do
@@ -339,48 +224,6 @@ class TestSharedShould < Test::Unit::TestCase
     end
   end
   
-  context "parameterized block" do
-    shared_context_should "be valid with shared context" do
-      setup do
-        assert [1, 2, 3], shared_value
-      end
-      
-      setup do |value|
-        assert [1, 2, 3], value
-      end
-      
-      setup do |first, second, third|
-        assert 1, first
-        assert 2, second
-        assert 3, third
-      end
-      
-      should "do something with shared_value" do
-        assert [1, 2, 3], shared_value
-      end
-      
-      should "do something with value block param" do |value|
-        assert [1, 2, 3], value
-      end
-      
-      should "do something with value block params" do |first, second, third|
-        assert 1, first
-        assert 2, second
-        assert 3, third
-      end
-    end
-    
-    shared_should "be valid with shared should" do |first, second, third|
-      assert 1, first
-      assert 2, second
-      assert 3, third
-    end
-    
-    should_be_valid_with_shared_context("with an array") { ['1', '2', '3'] }
-    
-    should_be_valid_with_shared_should("with an array") { ['1', '2', '3'] }
-  end
-  
   context "context directly under test class" do
     share_setup "for a true value" do
       @value = true
@@ -512,23 +355,10 @@ class TestSharedShould < Test::Unit::TestCase
           'test: .share_should without params when value in initializer when value is true should be a true value. ',
           'test: .share_should without params with value in initializer when value is true should be a true value. ',
           'test: .share_should without params with value in setup should be a true value. ',
-          'test: .shared_context_should with params be valid for specified value should call setup in shared context. ',
-          'test: .shared_context_should with params be valid for specified value should have specified value. ',
-          'test: .shared_context_should with params be valid for specified value should setup @expected_value. ',
-          'test: .shared_context_should without params be valid should call setup in shared context. ',
-          'test: .shared_context_should without params be valid should have true value. ',
-          'test: .shared_setup with params with shared setup value should have a true value from shared setup. ',
-          'test: .shared_setup without params with shared setup value should have a true value from shared setup. ',
-          'test: .shared_should with params should have specified value. ',
-          'test: .shared_should without params should have true value. ',
           'test: SharedShould should execute setup instance method. ',
           'test: context directly under test class for a valid context test should have a true value. ',
           'test: context directly under test class should be a valid should test. ',
           'test: for a valid context test in class should have a true value. ',
-          'test: parameterized block with an array be valid with shared context should do something with shared_value. ',
-          'test: parameterized block with an array be valid with shared context should do something with value block param. ',
-          'test: parameterized block with an array be valid with shared context should do something with value block params. ',
-          'test: parameterized block with an array should be valid with shared should. ',
           'test: shoulda macro should be a valid macro. ',
           'test: expected methods should have expected methods in test. ',
           "test: .share_context with params given true for a valid specified value should call setup in shared context. ",

data/test/test_shared_should_helper.rb

@@ -2,10 +2,6 @@ require 'helper'
 
 # Create a subclass for some shares
 class SubclassTestCase < Test::Unit::TestCase
-  shared_should "have true value for shared should helper" do
-    assert @value
-  end
-  
   share_should "be a true value for shared should helper" do
     assert @value
   end
@@ -17,22 +13,12 @@ end
 
 # re-open Test::Unit::TestCase class for some shares
 class Test::Unit::TestCase
-  shared_context_should "be valid for shared context helper" do
-    should "be true value" do
-      assert @value
-    end
-  end
-  
   share_context "for a true value for shared context helper" do
     should "be true value" do
       assert @value
     end
   end
   
-  shared_setup "for shared setup helper" do
-    @value = true
-  end
-  
   share_setup "for a true value for shared setup helper" do
     @value = true
   end
@@ -45,8 +31,6 @@ class TestSharedShouldHelper < SubclassTestCase
         @value = true
       end
       
-      should_have_true_value_for_shared_should_helper
-      
       use_should "be a true value for shared should helper"
     end
     
@@ -55,19 +39,9 @@ class TestSharedShouldHelper < SubclassTestCase
         @value = true
       end
       
-      should_be_valid_for_shared_context_helper
-      
       use_context "for a true value for shared context helper"
     end
     
-    context "with shared_setup helper" do
-      setup_for_shared_setup_helper
-      
-      should "be true value" do
-        assert @value
-      end
-    end
-    
     context "with share_setup helper" do
       use_setup "for a true value for shared setup helper"
       

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: shared_should
 version: !ruby/object:Gem::Version 
-  hash: 11
+  hash: 3
   prerelease: 
   segments: 
   - 0
-  - 6
-  - 6
-  version: 0.6.6
+  - 7
+  - 0
+  version: 0.7.0
 platform: ruby
 authors: 
 - Michael Pearce