shared_should 0.7.1 → 0.8.0

data/README.md

@@ -1,11 +1,11 @@
 # Shared Should - Share and reuse shoulds, contexts, and setups with Shoulda - easy, schmeasy.
 
 Shared Should allows you to easily create reusable shoulds, contexts and setups with familiar looking Shoulda syntax. Inspired by Rspec's shared example groups for context reuse, Shared Should allows sharing of contexts, shoulds,
-and setup blocks. Shared Should goes even further by allowing an initialization block and parameterization to fine-tune the usage of the shared functionality.
+and setup blocks. Shared Should goes even further by allowing chaining and parameterization to fine-tune the usage of the shared functionality.
 
 ## Quick-Start Examples
 
-Some quick examples to get you started using Shared Should. The domain of the examples is customers renting and purchasing textbooks - like we do at  [BookRenter.com](http://www.bookrenter.com "BookRenter.com").
+Some quick examples to get you started using Shared Should. The domain of the examples is customers renting and purchasing textbooks - something like we do at  [BookRenter.com](http://www.bookrenter.com "BookRenter.com").
 
 ### Shared Should
 
@@ -32,9 +32,9 @@ Sharing shoulds is easy.
                 use_should "be available for checkout"
             end
             
-            ### ...or DRY it up by using .when and an initialization block
-            use_should("be available for checkout").when("rentable") { @book.rentable = true }
-            use_should("be available for checkout").when("purchasable") { @book.purchasable = true }
+            ### ...or DRY it with chaining
+            setup("with a rentable book") { @book.rentable = true }.use_should("be available for checkout")
+            setup("with a purchasable book") { @book.purchasable = true }.use_should("be available for checkout")
         end
     end
 
@@ -64,6 +64,14 @@ Sharing setups is easy, too.
             
             should "be available for checkout" { assert @book.available_for_checkout? }
         end
+        
+        ### ...or DRY it with chaining
+        use_setup("for an in-stock book").
+            setup("with a rentable book") { @book.rentable = true }.
+            should "be available for checkout" { assert @book.available_for_checkout? }
+        use_setup("for an in-stock book").
+            setup("with a purchasable book") { @book.purchasable = true }.
+            should "be available for checkout" { assert @book.available_for_checkout? }
     end
     
 ### Shared Context
@@ -96,8 +104,8 @@ Sharing whole contexts? Schmeasy!
             end
             
             ### ...or DRY it up by using .when and an initialization block
-            use_context("for a book available for checkout").when("rentable") { @book.rentable = true }
-            use_context("for a book available for checkout").when("purchasable") { @book.purchasable = true }
+            setup("with a rentable book") { @book.rentable = true }.use_context("for a book available for checkout")
+            setup("with a purchasable book") { @book.purchasable = true }.use_context("for a book available for checkout")
         end
     end
 
@@ -111,28 +119,39 @@ 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 Blocks
+### Chaining
+
+Shared Should provides powerful chaining capabilities.
 
-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.
+Chained <tt>setup</tt>s and <tt>use\_setup</tt>s are applied to their parent context:
 
     context "Book" do
-        setup { @book = Book.new(:quantity => 1, :price => 10_00) }
-        
-        share_should "be available for checkout" { assert @book.available_for_checkout? }
-        
+        share_setup "for an in-stock book" do
+            @book = Book.new(:quantity => 1, :price => 10_00
+        end
+
         context "with a rentable book" do
-            # when share_should "be available for checkout" is executed, @book will have rentable equal to true
-            use_should("be available for checkout").with("a rentable book") { @book.rentable = true }
+            use_setup("for an in-stock book").setup { @book.rentable = true }
+            
+            should "be available for checkout" { assert @book.available_for_checkout? }
         end
-        
-        context "with a purchasable book" do
-            use_should("be available for checkout").when("purchasable") { @book.purchasable = true }
+    end
+
+Or chained <tt>setup</tt>s and <tt>use\_setup</tt>s can be chained to a <tt>should</tt>, <tt>use\_should</tt>, <tt>context</tt>, or <tt>use\_context</tt>:
+
+    context "Book" do
+        share_setup "for an in-stock book" do
+            @book = Book.new(:quantity => 1, :price => 10_00
         end
+
+        use_setup("for an in-stock book").
+            setup("for a rentable book") { @book.rentable = true }.
+            should("be available for checkout") { assert @book.available_for_checkout? }
     end
 
 ### Parameterizing Shares
 
-Shared functions can also be parameterized using block parameters. This can be done for shared setups, shoulds, and the setups and shoulds contained within a shared context. The value passed to the shared function is the return value of the <tt>given</tt> parameterization block. The below example parameterizes a shared setup.
+Shared functions can also be parameterized using block parameters. This can be done for shared setups, shared shoulds, and the <tt>setup</tt>s and <tt>should</tt>s contained within a shared context. The value passed to the shared function is the return value of the <tt>given</tt> parameterization block. The below example parameterizes a shared setup.
 
     context "Book" do
         share_setup "for an in-stock book" do |rentable|
@@ -200,39 +219,6 @@ 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.7.1
+0.8.0

data/lib/shared_should.rb

@@ -55,6 +55,10 @@ class Test::Unit::TestCase
       test_block.bind(self).call()
     end
   end
+  
+  def call_block_shared_value(test_block)
+    self.shared_value = call_block_with_shared_value(test_block)
+  end
 end
 
 module Shoulda::SharedContext
@@ -93,25 +97,19 @@ module Shoulda::SharedContext
     end
   
     def use_should(shared_name)
-      shared_proxy = Shoulda::SharedProxy.new(self, :should, shared_name)
-      shared_proxies << shared_proxy
-      return shared_proxy
+      return add_shared_proxy.use_should(shared_name)
     end
     
     def use_context(shared_name)
-      shared_proxy = Shoulda::SharedProxy.new(self, :context, shared_name)
-      shared_proxies << shared_proxy
-      return shared_proxy
+      return add_shared_proxy.use_context(shared_name)
     end
     
     def use_setup(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)
-      end
-      return shared_proxy
+      return add_shared_proxy.use_setup(shared_name)
+    end
+  
+    def setup(name = nil, &block)
+      return add_shared_proxy.setup(name, &block)
     end
   
     def context(name = nil, &block)
@@ -138,19 +136,9 @@ module Shoulda::SharedContext
       end
     end
 
-    def setup(&block)
-      if block.nil?
-        setup_without_param_support()
-      else
-        setup_without_param_support() do
-          call_block_with_shared_value(block)
-        end
-      end
-    end
-  
     def share_context(shared_context_name, &shared_context_block)
       wrapping_shared_context_block = Proc.new do
-        context shared_context_name do
+        context share_description do
           merge_block(&shared_context_block)
         end
       end
@@ -160,7 +148,7 @@ module Shoulda::SharedContext
 
     def share_should(shared_should_name, &shared_should_block)
       shared_context_block = Proc.new do
-        should shared_should_name do
+        should share_description do
           call_block_with_shared_value(shared_should_block)
         end
       end
@@ -199,6 +187,10 @@ module Shoulda::SharedContext
     end
     
   private
+  
+    def add_shared_proxy
+      (shared_proxies << Shoulda::SharedProxy.new(self)).last
+    end
 
     def shared_context_for_block(shared_block)
       eval("self", shared_block.binding)
@@ -256,77 +248,120 @@ end
 
 
 class Shoulda::SharedProxy
-  attr_accessor :shared_name, :share_type, :description, :block_configs, :context
+  attr_accessor :source_context, :setup_block_configs, :test_type, :test_block, :test_description, :current_action
   
-  def initialize(context, share_type, shared_name)
-    self.context = context
-    self.share_type = share_type
-    self.shared_name = shared_name
-    self.block_configs = []
+  def initialize(source_context)
+    self.setup_block_configs = []
+    self.source_context = source_context
   end
   
-  def with(description = nil, &initialization_block)
-    add_proxy_block(:with, "with", description, &initialization_block)
+  def setup(description = nil, &initialization_block)
+    add_setup_block(:setup, description, &initialization_block)
   end
   
-  def when(description = nil, &initialization_block)
-    add_proxy_block(:with, "when", description, &initialization_block)
+  def use_setup(share_name)
+    add_setup_block(:use_setup, share_name, &source_context.find_shared_block(:setup, share_name))
   end
   
   def given(description = nil, &initialization_block)
-    # given needs to execute before its with_setup
-    add_proxy_block(:given, "given", description, :disable_and => true, :insert_block_before_end => @current_action == :with_setup, &initialization_block)
+    valid_share_types = [:use_setup, :use_should, :use_context]
+    @failed = true and raise ArgumentError, "'given' can only appear after #{valid_share_types.join(', ')}" unless valid_share_types.include?(current_action)
+    
+    add_setup_block(:given, description ? "given #{description}" : nil, &initialization_block)
   end
   
-  def with_setup(description)
-    initialization_block = context.find_shared_block(:setup, description)
-    add_proxy_block(:with_setup, "with setup", description, :disable_and => true, &initialization_block)
+  def should(description = nil, options = {}, &should_block)
+    shared_context_block = Proc.new do
+      should share_description do
+        call_block_with_shared_value(should_block)
+      end
+    end
+    add_test_block(:should, description, &shared_context_block)
   end
   
-  def execute
-    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)
+  def use_should(share_name)
+    add_test_block(:use_should, share_name, &source_context.find_shared_block(:should, share_name))
+  end
+  
+  def context(description = nil, &context_block)
+    shared_context_block = Proc.new do
+      context share_description do
+        merge_block(&context_block)
       end
-      shared_proxy.context.find_shared_block(shared_proxy.share_type, shared_proxy.shared_name).bind(self).call
     end
+    add_test_block(:context, description, &shared_context_block)
   end
   
-  def execute_and_set_shared_value(test_context)
-    initialization_block.bind(test_context).call
+  def use_context(share_name)
+    add_test_block(:use_context, share_name, &source_context.find_shared_block(:context, share_name))
   end
   
-  def initialization_block
-    the_block_configs = block_configs
-    return Proc.new do
-      the_block_configs.collect do |block_config|
-        block = block_config[:block]
-         # really should only allow value set from :given blocks but done for compatability
-        if [:given, :with, :when].include?(block_config[:action])
-          setup_shared_value(block)
-        else
-          call_block_with_shared_value(block) if block
+  def execute
+    return if @failed
+    
+    shared_proxy = self
+    if test_type == :should || test_type == :context || test_type == :use_should || test_type == :use_context
+      # create a new context for setups and should/context
+      source_context.context setup_block_configs_description do
+        setup_without_param_support do
+          shared_proxy.setup_block_configs.each do |config|
+            call_block_shared_value(config[:block])
+          end
         end
-      end.last
+        
+        # share_description called when creating test names
+        eval("def share_description; #{shared_proxy.send(:escaped_test_description)}; end")
+        merge_block(&shared_proxy.test_block)
+      end
+    else
+      # call setups directly in this context
+      source_context.setup_without_param_support do
+        shared_proxy.setup_block_configs.each do |config|
+          call_block_shared_value(config[:block])
+        end
+      end
     end
   end
   
 private
+
+  def escaped_test_description
+    test_description.nil? ? 'nil' : "'#{test_description.gsub('\\', '\\\\\\').gsub("'", "\\\\'")}'"
+  end
   
-  def add_proxy_block(action, conditional, description, options = {}, &block)
-    @current_action = action
-    if description
-      and_text = options[:disable_and] ? ' ' : ' and '
-      self.description = "#{self.description}#{self.description.nil? ? nil : and_text}#{conditional} #{description}"
+  def setup_block_configs_description
+    @setup_block_configs_description
+  end
+  
+  def add_test_block(test_type, description, &test_block)
+    @failed = true and raise ArgumentError, 'Only a single should or context can be chained' if self.test_type
+    
+    self.test_type = test_type
+    self.current_action = test_type
+    self.test_description = description
+    self.test_block = test_block
+    return self
+  end
+
+  def add_setup_block(action, description, &block)
+    if test_type
+      @failed = true and raise ArgumentError, "'#{action}' may not be applied" unless action == :given
+      # add final given description to test description
+      self.test_description = "#{test_description} #{description}" if description
+      description = nil
     end
-    block_config = {:block => block, :action => action}
-    if options[:insert_block_before_end]
-      self.block_configs.insert(-2, block_config)
+    
+    setup_block_config = {:block => block, :action => action, :description => description}
+    if action == :given and (current_action == :setup || current_action == :use_setup)
+      setup_block_configs.insert(-2, setup_block_config)
     else
-      self.block_configs << block_config
+      setup_block_configs << setup_block_config
     end
+    if description
+      @setup_block_configs_description = "#{@setup_block_configs_description}#{' ' if @setup_block_configs_description}#{description}"
+    end
+    
+    self.current_action = action
     return self
   end
 end

data/shared_should.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{shared_should}
-  s.version = "0.7.1"
+  s.version = "0.8.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Michael Pearce"]
-  s.date = %q{2011-03-21}
+  s.date = %q{2011-04-05}
   s.description = %q{Share and reuse shoulds, contexts, and setup in Shoulda.}
   s.email = %q{michael.pearce@bookrenter.com}
   s.extra_rdoc_files = [

data/test/test_shared_should.rb

@@ -58,7 +58,7 @@ class TestSharedShould < Test::Unit::TestCase
       end
     
       context "with value in initializer" do
-        use_context("for a valid value").when("a true value") { @value = true }
+        setup("with a true value") { @value = true }.use_context("for a valid value")
       end
     end
     
@@ -96,8 +96,7 @@ class TestSharedShould < Test::Unit::TestCase
           end
         end
         
-        use_context("for a chained value").with("an initialization chain") { @chain = true }.given("true") { true }
-        use_context("for a chained value").when("using initialization chain") { @chain = true }.given("true") { true }
+        setup("for an initialization chain") { @chain = true }.use_context("for a chained value").given("true") { true }
       end
     end
   end
@@ -117,11 +116,11 @@ class TestSharedShould < Test::Unit::TestCase
       end
       
       context "when value in initializer" do
-        use_should("be a true value").when("value is true") { @value = true }
+        setup("with true value") { @value = true }.use_should("be a true value")
       end
       
       context "with value in initializer" do
-        use_should("be a true value").when("value is true") { @value = true }
+        setup("with true value") { @value = true }.use_should("be a true value")
       end
     end
     
@@ -142,8 +141,7 @@ class TestSharedShould < Test::Unit::TestCase
           assert value
         end
         
-        use_should("be a valid specified value").when("using initialization chain") { @chain = true }.given("true") { true }
-        use_should("be a valid specified value").with("an initialization chain") { @chain = true }.given("true") { true }
+        setup("with initialization chain") { @chain = true }.use_should("be a valid specified value").given("true") { true }
       end
     end
   end
@@ -177,7 +175,7 @@ class TestSharedShould < Test::Unit::TestCase
           @value = @initialization_value
         end
   
-        use_setup("for value").when("initialization value is true") { @initialization_value = true }
+        setup("with initialization true value") { @initialization_value = true }.use_setup("for value")
   
         should "have a true value from shared setup" do
           assert @value
@@ -213,8 +211,7 @@ class TestSharedShould < Test::Unit::TestCase
           @value = value
         end
         
-        use_setup("for value").when("using initialization chain") { @chain = true }.given("true") { true }
-        use_setup("for value").with("an initialization chain") { @chain = true }.given("true") { true }
+        use_setup("for value").given("true") { true }.setup("with chain true") { @chain = true }
         
         should "have used share with chain and params" do
           assert @chain
@@ -251,62 +248,148 @@ class TestSharedShould < Test::Unit::TestCase
       setup do
         @count = 0
       end
-  
-      share_setup "shared setup 1" do
+      
+      share_setup "for shared setup 1" do |count|
         assert_equal 1, @count
+        assert_equal count, @count
         @count += 1
       end
-  
-      share_setup "shared setup 2" do
+      
+      share_setup "for shared setup 2" do |count|
         assert_equal 3, @count
+        assert_equal count, @count
         @count += 1
       end
-  
-      share_should "be valid shared should" do
+      
+      share_should "be valid shared should" do |count|
         assert_equal 7, @count
+        assert_equal count, @count
       end
-  
-      use_should("be valid shared should").
-        with_setup("shared setup 1").given("setup value") { assert_equal 0, @count; @count += 1 }.
-        with_setup("shared setup 2").given("setup value") { assert_equal 2, @count; @count += 1 }.
-        with("initialization value") { assert_equal 4, @count; @count += 1 }.
-        with("initialization value") { assert_equal 5, @count; @count += 1 }.
-        given { assert_equal 6, @count; @count += 1 }
+      
+      use_setup("for shared setup 1").given("increment 1") { assert_equal 0, @count; @count += 1 }.
+        use_setup("for shared setup 2").given("increment 2") { assert_equal 2, @count; @count += 1 }.
+        setup("with setup value 3") { assert_equal 4, @count; @count += 1 }.
+        setup("with setup value 4") { assert_equal 5, @count; @count += 1 }.
+        use_should("be valid shared should").given("increment 3") { assert_equal 6, @count; @count += 1 }
+    end
+    
+    context "with invalid given" do
+      begin
+        setup {}.setup { assert false }.given {}
+        raise "Should not allow given after setup"
+      rescue ArgumentError
+        # correct
+      end
+      
+      begin
+        setup {}.should("fail") { assert false }.given {}
+        raise "Should not allow given after should"
+      rescue ArgumentError
+        # correct
+      end
+      
+      begin
+        setup {}.context do
+          should("fail") { assert false }
+        end.given {}
+        raise "Should not allow given after should"
+      rescue ArgumentError
+        # correct
+      end
+      
+      begin
+        share_setup("for setup") { assert false }
+        use_setup("for setup").given {}.given {}
+        raise "Should not allow given after another given"
+      rescue ArgumentError
+        # correct
+      end
+    end
+    
+    context "with invalid setup chain to should" do
+      begin
+        setup {}.should("1") { assert false }.setup { assert false }
+        raise "Should not allow setup chained after should"
+      rescue ArgumentError
+        # correct
+      end
+    end
+    
+    context "with invalid chain to should" do
+      begin
+        setup {}.should("1") { assert false }.should("2") { assert false }
+        raise "Should not allow chained shoulds"
+      rescue ArgumentError
+        # correct
+      end
+    end
+    
+    context "with invalid chained contexts" do
+      begin
+        setup {}.context("1") { should("1") { assert false } }.should("2") { assert false }
+        raise "Should not allow chain to context"
+      rescue ArgumentError
+        # correct
+      end
+    end
+    
+    context "with should" do
+      setup("for true value") { @value = true }.should("be true value") do
+        assert @value
+      end
+    end
+    
+    context "with shared should" do
+      share_should "be true value" do |value|
+        assert @value
+        assert value
+      end
+      
+      setup("for true value") { @value = true }.use_should("be true value").given("true") { true }
     end
     
-    context "with parameters" do
-      share_setup "shared setup 1" do |value|
-        assert_equal :one, value
+    context "with context" do
+      setup("for true value") { @value = true }.context do
+        should "be true value" do
+          assert @value
+        end
       end
+    end
     
-      share_setup "shared setup 2" do |value|
-        assert_equal :two, value
+    context "with shared context" do
+      share_context "for a shared context" do
+        should "have a true value" do |value|
+          assert @value
+          assert value
+        end
       end
       
-      share_should "be valid shared should with parameter" do |value|
-        assert_equal :three, @value
-        assert_equal :four, value
+      setup("for true value") { @value = true }.use_context("for a shared context").given("true") { true }
+    end
+  end
+  
+  context "with unusual characters in name" do
+    name = "-- \\ ' \" --"
+    
+    share_context name do
+      should "be valid" do
+        assert true
       end
+    end
     
-      use_should("be valid shared should with parameter").
-        with_setup("shared setup 1").given { :one }.
-        with_setup("shared setup 2").given { :two }.
-        with("initialization value") { @value = :three }.
-        given { :four }
-        
-      # TODO: this assertion enforces that only a trailing 'given' block is used for parameter argument
-      # For legacy reasons, return value from with/when currently can also be used for parameter arguement
-      #
-      # share_should "be valid shared should without parameter" do
-      #   assert_equal :three, @value
-      #   assert_nil shared_value
-      # end
-      # 
-      # use_should("be valid shared should without parameter").
-      #   with_setup("shared setup 1").given { :one }.
-      #   with_setup("shared setup 2").given { :two }.
-      #   with("initialization value") { @value = :three }
+    use_context name
+    
+    share_should name do
+      assert true
+    end
+    
+    use_should name
+    
+    share_setup name do
+      assert true
     end
+    
+    use_setup name
   end
   
   # ensure should macros work
@@ -343,35 +426,38 @@ class TestSharedShould < Test::Unit::TestCase
     should "have expected methods in test" do
       # ensure test methods are created
       expected_method_names = [
-          'test:  should be a valid should test in class. ',
-          'test: .share_context without params with value in initializer when a true value for a valid value should call setup in shared context. ',
-          'test: .share_context without params with value in initializer when a true value for a valid value should have true value. ',
-          'test: .share_context without params with value in setup for a valid value should call setup in shared context. ',
-          'test: .share_context without params with value in setup for a valid value should have true value. ',
-          'test: .share_setup with param block with chaining should have used share with chain and params. ',
-          'test: .share_setup with param block with shared setup value should have a true value from shared setup. ',
-          'test: .share_setup without params with initialization block should have a true value from shared setup. ',
-          'test: .share_setup without params without initialization block should have a true value from shared setup. ',
-          '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: 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: 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. ",
-          "test: .share_context with params with chaining with an initialization chain given true for a chained value should chain initialization block and be with params. ",
-          "test: .share_context with params given true for a valid specified value should setup @expected_value. ",
-          "test: .share_should with params with chaining with an initialization chain given true should be a valid specified value. ",
-          "test: .share_context with params given true for a valid specified value should have specified value. ",
-          "test: .share_context with params with chaining when using initialization chain given true for a chained value should chain initialization block and be with params. ",
-          "test: .share_should with params with chaining when using initialization chain given true should be a valid specified value. ",
-          "test: .share_should with params given true should be a valid specified value. ",
-          "test: chaining with parameters with setup shared setup 1 with setup shared setup 2 and with initialization value should be valid shared should with parameter. ",
-          "test: chaining with ordering verification with setup shared setup 1 given setup value with setup shared setup 2 given setup value and with initialization value and with initialization value should be valid shared should. "
-        ].inject({}) do |hash, expected_method_name|
+          "test: .share_should without params with value in setup should be a true value. ",
+          "test: .share_context without params with value in setup for a valid value should call setup in shared context. ",
+          "test: .share_context without params with value in initializer with a true value for a valid value should have true value. ",
+          "test: for a valid context test in class should have a true value. ",
+          "test: .share_should with params should be a valid specified value given true. ",
+          "test: .share_should without params with value in initializer with true value should be a true value. ",
+          "test: .share_should without params when value in initializer with true value should be a true value. ",
+          "test: .share_should with params with chaining with initialization chain should be a valid specified value given true. ",
+          "test: .share_setup with param block with shared setup value should have a true value from shared setup. ",
+          "test: .share_context without params with value in initializer with a true value for a valid value should call setup in shared context. ",
+          "test: .share_context with params with chaining for an initialization chain for a chained value given true should chain initialization block and be with params. ",
+          "test:  should be a valid should test in class. ",
+          "test: .share_setup without params with initialization block should have a true value from shared setup. ",
+          "test: .share_context without params with value in setup for a valid value should have true value. ",
+          "test: shoulda macro should be a valid macro. ",
+          "test: .share_setup with param block with chaining should have used share with chain and params. ",
+          "test: .share_context with params for a valid specified value given true should call setup in shared context. ",
+          "test: chaining with ordering verification for shared setup 1 given increment 1 for shared setup 2 given increment 2 with setup value 3 with setup value 4 should be valid shared should given increment 3. ",
+          "test: .share_context with params for a valid specified value given true should setup @expected_value. ",
+          "test: .share_context with params for a valid specified value given true should have specified value. ",
+          "test: chaining with shared should for true value should be true value given true. ",
+          "test: chaining with should for true value should be true value. ",
+          "test: chaining with context for true value should be true value. ",
+          "test: expected methods should have expected methods in test. ",
+          "test: chaining with shared context for true value for a shared context given true should have a true value. ",
+          "test: context directly under test class should be a valid should test. ",
+          "test: context directly under test class for a valid context test should have a true value. ",
+          "test: .share_setup without params without initialization block should have a true value from shared setup. ",
+          "test: SharedShould should execute setup instance method. ",
+          "test: with unusual characters in name -- \\ ' \" -- should be valid. ",
+          "test: with unusual characters in name should -- \\ ' \" --. "
+      ].inject({}) do |hash, expected_method_name|
         hash[expected_method_name] = true
         hash
       end

data/test/test_shared_should_helper.rb

@@ -2,10 +2,6 @@ require 'helper'
 
 # Create a subclass for some shares
 class SubclassTestCase < Test::Unit::TestCase
-  share_should "be a true value for shared should helper" do
-    assert @value
-  end
-  
   should "have a test" do
     assert true
   end
@@ -13,6 +9,10 @@ end
 
 # re-open Test::Unit::TestCase class for some shares
 class Test::Unit::TestCase
+  share_should "be a true value for shared should helper" do
+    assert @value
+  end
+  
   share_context "for a true value for shared context helper" do
     should "be true value" do
       assert @value
@@ -22,6 +22,7 @@ class Test::Unit::TestCase
   share_setup "for a true value for shared setup helper" do
     @value = true
   end
+  
 end
 
 class TestSharedShouldHelper < SubclassTestCase

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: shared_should
 version: !ruby/object:Gem::Version 
-  hash: 1
+  hash: 63
   prerelease: 
   segments: 
   - 0
-  - 7
-  - 1
-  version: 0.7.1
+  - 8
+  - 0
+  version: 0.8.0
 platform: ruby
 authors: 
 - Michael Pearce
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-21 00:00:00 -07:00
+date: 2011-04-05 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency