fakes 0.4.0 → 0.4.1

data/README.md

@@ -72,10 +72,16 @@ collaborator.stub(:method).with(1).and_return(first_return_value)
 #Setup a return value for 2
 collaborator.stub(:method).with(2).and_return(second_return_value)
 
+
 #Setup a return value when called with everything else 
 #if you are going to use this, make sure it is used after 
 #setting up return values for specific arguments
 collaborator.stub(:method).and_return(value_to_return_with_arguments_other_than_1_and_2)
+
+
+#Setup a return value for any number greater than 2 - this makes use of the argument matching syntax described [here](http://blog.developwithpassion.com/2012/06/09/fakes-and-in-turn-fakes-rspec-new-feature-arbitrary-argument-matching-for-setup-and-verification-of-calls/)
+
+collaborator.stub(:method).with(arg_match.greater_than(2)).and_return(second_return_value)
 ```
 
 ##Verifying calls made to the fake
@@ -145,26 +151,14 @@ it "should trigger its collaborator with the correct message" do
 end
 ```
 
-The nice thing is we can make the assertions after the fact, as opposed to needing to do them as part of setup, which I find is a much more natural way to read things, when you need to do this style of test. Notice that the called_with method return a method_invocation that will be nil if the call was not received. My recommendation would be to create a test utility method that allows you to leverage your testing frameworks assertion library to make the above assertion more terse. The
-following rspec sample demonstrates:
-
-```ruby
-module RSpec
-  Matchers.define :have_received do|symbol,*args|
-    match do|fake|
-      fake.received(symbol).called_with(*args) != nil
-    end
-  end
-end
-```
+The nice thing is we can make the assertions after the fact, as opposed to needing to do them as part of setup, which I find is a much more natural way to read things, when you need to do this style of test. Notice that the called_with method return a method_invocation that will be nil if the call was not received. My recommendation would be to use the [fakes-rspec](http://github.com/developwithpassion/fakes-rpsec) library (if you are using rspec) which gives you access to a predefined matcher that you can use as follows:
 
-Using the above utility method turns the previous assertion:
 
 ```ruby
 collaborator.received(:send_message).called_with("Hello World").should_not be_nil
 ```
 
-To this:
+Can be done in fakes-rspec by doing this:
 
 ```ruby
 collaborator.should have_received(:send_message,"Hello World")
@@ -172,7 +166,7 @@ collaborator.should have_received(:send_message,"Hello World")
 
 ###Verifying that a call should not have been made
 
-Currently verifying that a call was not made does not take the arguments into consideration. It just ensures that no calls to a particular named method were made. Here is an example:
+Verifying that a call was not made can be done with or without arguments:
 
 ```ruby
 class FirstCollaborator
@@ -221,9 +215,11 @@ describe SomeItem do
   it "should not trigger its second collaborator" do
     #again, here would be another option to use a convienience test utility method
     second.never_received?(:send_message).should be_true
+    #with fakes-rspec it looks like this
+    second.should_not have_received(:send_message)
   end
  end
 end
 ```
 
-As you can see, in this test we want to verify that one collaborator was triggered and the other not.
+As you can see, in this test we want to verify that one collaborator was triggered and the other not. If you cared about specifying arguments it should not have been called with, you can do the same as a regular verification.

data/lib/core/arg_matching/matches.rb

@@ -2,31 +2,31 @@ module Fakes
   class Matches
     class << self
       def not_nil
-        condition(lambda{|item| item != nil})
+        condition{|item| item != nil}
       end
 
       def nil
-        condition(lambda{|item| item == nil})
+        condition{|item| item == nil}
       end
 
       def any
-        condition(lambda{|ignored| true})
+        condition{|ignored| true}
       end
 
       def greater_than(value)
-        condition(lambda{|number| number > value})
+        condition{|number| number > value}
       end
       
 
       def in_range(range)
-        condition(lambda{|item| range === item})
+        condition{|item| range === item}
       end
 
       def regex(regex)
-        condition(lambda{|string| regex =~ string})
+        condition{|string| regex =~ string}
       end
 
-      def condition(conditional_block)
+      def condition(&conditional_block)
         return BlockArgMatcher.new(conditional_block)
       end
     end

data/lib/core/version.rb

@@ -1,3 +1,3 @@
 module Fakes
-  VERSION = "0.4.0"
+  VERSION = "0.4.1"
 end

data/spec/specs/arg_matching_scenarios_spec.rb

@@ -39,7 +39,7 @@ module Fakes
 
       fake.hello(7)
 
-      fake.received(:hello).called_with(Matches.condition(lambda{|item| item < 10})).should_not be_nil
+      fake.received(:hello).called_with(Matches.condition{|item| item < 10}).should_not be_nil
     end
 
     it "should be able to intercept by mixing regular arguments with matchers" do

data/spec/specs/matches_spec.rb

@@ -34,7 +34,7 @@ module Fakes
       end
 
       it "should be able to create a lambda based matcher" do
-        match = Matches.condition(lambda{|item| item > 3})
+        match = Matches.condition{|item| item > 3}
         match.matches?(2).should be_false
         match.matches?(7).should be_true
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fakes
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
   prerelease: 
 platform: ruby
 authors: