shared_should 0.6.2 → 0.6.3

data/README.md

@@ -114,7 +114,7 @@ Some rules:
 
 ### Initialization Block
 
-The shared invocation accepts an initialization block by chaining <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.
+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.
 
     context "Book" do
         setup { @book = Book.new(:quantity => 1, :price => 10_00) }
@@ -123,7 +123,7 @@ The shared invocation accepts an initialization block by chaining <tt>when</tt>
         
         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").when("rentable") { @book.rentable = true }
+            use_should("be available for checkout").with("a rentable book") { @book.rentable = true }
         end
         
         context "with a purchasable book" do
@@ -133,7 +133,7 @@ The shared invocation accepts an initialization block by chaining <tt>when</tt>
 
 ### 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>with</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, 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.
 
     context "Book" do
         share_setup "for an in-stock book" do |rentable|
@@ -142,7 +142,7 @@ Shared functions can also be parameterized using block parameters. This can be d
 
         context "with rentable book" do
             # the return value of the block is "true" which will be passed as the block parameter "rentable"
-            use_setup("for an in-stock book").with { true }
+            use_setup("for an in-stock book").given { true }
             
             should "be available for checkout" { assert @book.available_for_checkout? }
         end
@@ -159,8 +159,8 @@ Here is a parameterized shared should.
                 assert_false @book.available_for_checkout?
             end
 
-            use_should("be unavailable for checkout for price").with("zero") { 0 }
-            use_should("be unavailable for checkout for price").with("a negative price") { -1 }
+            use_should("be unavailable for checkout for price").given("zero") { 0 }
+            use_should("be unavailable for checkout for price").given("a negative price") { -1 }
         end
     end
 
@@ -180,7 +180,7 @@ And a parameterized shared context.
                 should "be rentable or purchasable" { assert @book.rentable || @book.purchasable }
             end
 
-            use_context("for a book available for checkout at price").with("a positive price") { 10_00 }
+            use_context("for a book available for checkout at price").given("a positive price") { 10_00 }
         end
     end
 
@@ -196,8 +196,8 @@ The shared functions also accept multiple parameters when the parameterization b
                 assert_false @book.available_for_checkout?
             end
 
-            use_should("be unavailable for checkout for quantity and price").with("a zero quantity") { [0, 10_00] }
-            use_should("be unavailable for checkout for quantity and price").with("a zero price") { [1, 0] }
+            use_should("be unavailable for checkout for quantity and price").given("a zero quantity") { [0, 10_00] }
+            use_should("be unavailable for checkout for quantity and price").given("a zero price") { [1, 0] }
         end
     end
 
@@ -217,7 +217,7 @@ In your test file:
 
     class BookTest < Test::Unit::TestCase
         context "with an in-stock book" do
-            use_setup("for an in-stock book").with { [true, true] }
+            use_setup("for an in-stock book").given { [true, true] }
             
             should "be in stock" { assert @book.quantity > 0 }
         end

data/VERSION

@@ -1 +1 @@
-0.6.2
+0.6.3

data/lib/shared_should.rb

@@ -18,8 +18,8 @@ end
 class Test::Unit::TestCase
   attr_accessor :shared_value
   attr_accessor :shared_name
-  @@shared_proxies_executed = false
-  @@setup_blocks = []
+  @@shared_proxies_executed = {}
+  @@setup_blocks = {}
 
   class << self
     # these methods need to be aliased for both the test class and the should context
@@ -27,11 +27,12 @@ class Test::Unit::TestCase
   end
   
   def self.suite
-    unless @@shared_proxies_executed
+    # assuming 'suite' is called before executing any tests - may be a poor assumption. Find something better?
+    unless @@shared_proxies_executed[self]
       shared_proxies.each do |shared_proxy|
         shared_proxy.execute(self)
       end
-      @@shared_proxies_executed = true
+      @@shared_proxies_executed[self] = true
     end
     
     suite_without_shared_should_execute
@@ -42,13 +43,14 @@ class Test::Unit::TestCase
   end
 
   def setup
-    @@setup_blocks.each do |setup_block|
+    (@@setup_blocks[self.class] || []).each do |setup_block|
       setup_block.bind(self).call
     end
   end
 
   def self.setup(&setup_block)
-    @@setup_blocks << setup_block
+    @@setup_blocks[self] = [] unless @@setup_blocks[self]
+    @@setup_blocks[self] << setup_block
   end
   
   def setup_shared_values(name, initialization_block)
@@ -317,14 +319,16 @@ class Shoulda::SharedProxy
     self.initialization_blocks = []
   end
   
+  def with(description = nil, &initialization_block)
+    with_helper("with", description, &initialization_block)
+  end
+  
   def when(description = nil, &initialization_block)
-    when_helper("when", description, &initialization_block)
-    return self
+    with_helper("when", description, &initialization_block)
   end
   
-  def with(description = nil, &initialization_block)
-    when_helper("with", description, &initialization_block)
-    return nil
+  def given(description = nil, &initialization_block)
+    with_helper("given", description, :disable_and => true, &initialization_block)
   end
   
   def execute(context)
@@ -341,10 +345,12 @@ class Shoulda::SharedProxy
   
   private
   
-  def when_helper(conditional, description = nil, &initialization_block)
+  def with_helper(conditional, description, options = {}, &initialization_block)
     if description
-      self.description = "#{self.description}#{self.description.nil? ? nil : ' and '}#{conditional} #{description}"
+      and_text = options[:disable_and] ? ' ' : ' and '
+      self.description = "#{self.description}#{self.description.nil? ? nil : and_text}#{conditional} #{description}"
     end
     self.initialization_blocks << initialization_block
+    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.6.2"
+  s.version = "0.6.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Michael Pearce"]
-  s.date = %q{2011-03-04}
+  s.date = %q{2011-03-18}
   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

@@ -64,7 +64,7 @@ class TestSharedShould < Test::Unit::TestCase
         end
       end
       
-      use_context("for a valid specified value").with("true") { true }
+      use_context("for a valid specified value").given("true") { true }
       
       context "with chaining" do
         share_context "for a chained value" do
@@ -74,7 +74,8 @@ class TestSharedShould < Test::Unit::TestCase
           end
         end
         
-        use_context("for a chained value").when("using initialization chain") { @chain = true }.with("true") { true }
+        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 }
       end
     end
   end
@@ -162,7 +163,7 @@ class TestSharedShould < Test::Unit::TestCase
         assert_equal value, @value
       end
       
-      use_should("be a valid specified value").with("true") { true }
+      use_should("be a valid specified value").given("true") { true }
       
       context "with chaining" do
         share_should "be a valid specified value" do |value|
@@ -170,8 +171,8 @@ class TestSharedShould < Test::Unit::TestCase
           assert value
         end
         
-        use_should("be a valid specified value").when("using initialization chain") { @chain = true }.with("true") { true }
-        use_should("be a valid specified value").when("using initialization chain xxxx") { @chain = true }.with("true") { true }
+        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 }
       end
     end
   end
@@ -288,7 +289,7 @@ class TestSharedShould < Test::Unit::TestCase
           @value = false
         end
       
-        use_setup("for value").with("true") { true }
+        use_setup("for value").given("true") { true }
       
         should "have a true value from shared setup" do
           assert @value
@@ -305,7 +306,8 @@ class TestSharedShould < Test::Unit::TestCase
           @value = value
         end
         
-        use_setup("for value").when("using initialization chain") { @chain = true }.with("true") { true }
+        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 }
         
         should "have used share with chain and params" do
           assert @chain
@@ -431,58 +433,70 @@ class TestSharedShould < Test::Unit::TestCase
     end
   end
   
-  # ensure test methods are created
-  expected_method_names = [
-      'test:  should be a valid should test in class. ',
-      'test: .share_context with params with chaining when using initialization chain and with true for a chained value should chain initialization block and be with params. ',
-      'test: .share_context with params with true for a valid specified value should call setup in shared context. ',
-      'test: .share_context with params with true for a valid specified value should have specified value. ',
-      'test: .share_context with params with true for a valid specified value should setup @expected_value. ',
-      '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 with params with chaining when using initialization chain and with true should be a valid specified value. ',
-      'test: .share_should with params with chaining when using initialization chain xxxx and with true should be a valid specified value. ',
-      'test: .share_should with params with true should be a valid specified value. ',
-      '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. '
-    ].inject({}) do |hash, expected_method_name|
-    hash[expected_method_name] = true
-    hash
-  end
-  actual_method_names = suite.tests.inject({}) do |hash, test_case|
-    hash[test_case.method_name] = true
-    hash
-  end
-  
-  expected_method_names.each do |method_name, value|
-    raise "Test method not found: '#{method_name}'" unless actual_method_names.include?(method_name)
-  end
-  actual_method_names.each do |method_name, value|
-    raise "Unexpected test method: '#{method_name}'" unless expected_method_names.include?(method_name)
+  context "expected methods" do
+    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: .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. ",
+          "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. "
+        ].inject({}) do |hash, expected_method_name|
+        hash[expected_method_name] = true
+        hash
+      end
+      actual_method_names = self.class.suite.tests.inject({}) do |hash, test_case|
+        hash[test_case.method_name] = true
+        hash
+      end
+  
+      actual_methods_not_found = []
+      actual_method_names.each do |method_name, value|
+        actual_methods_not_found << method_name unless expected_method_names.include?(method_name)
+      end
+      assert_equal [], actual_methods_not_found, "Unknown methods exist in the test suite"
+      
+      expected_methods_not_found = []
+      expected_method_names.each do |method_name, value|
+         expected_methods_not_found << method_name unless actual_method_names.include?(method_name)
+      end
+      assert_equal [], expected_methods_not_found, "Unknown methods exist in the list of expected tests"
+      
+    end
   end
 end

data/test/test_shared_should_helper.rb

@@ -1,6 +1,6 @@
 require 'helper'
 
-# re-open ActiveSupport::TestCase class for some shares
+# Create a subclass for some shares
 class SubclassTestCase < Test::Unit::TestCase
   shared_should "have true value for shared should helper" do
     assert @value

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: shared_should
 version: !ruby/object:Gem::Version 
-  hash: 3
+  hash: 1
   prerelease: 
   segments: 
   - 0
   - 6
-  - 2
-  version: 0.6.2
+  - 3
+  version: 0.6.3
 platform: ruby
 authors: 
 - Michael Pearce
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-04 00:00:00 -08:00
+date: 2011-03-18 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency