fakes 0.2.3 → 0.3.0

data/lib/core/arg_behaviour.rb

@@ -1,6 +1,10 @@
 module Fakes
   module ArgBehaviour
-    attr_accessor :return_value,:times_called
+    attr_accessor :return_value,:times_called,:arg_matcher
+
+    def initialize_matcher_using(args)
+      @arg_matcher = ArgMatchFactory.create_arg_matcher_using(args)
+    end
 
     def and_return(item)
       @return_value = item
@@ -16,11 +20,11 @@ module Fakes
     end
 
     def matches?(args)
-      return @args == args
+      return @arg_matcher.matches?(args)
     end
 
     def was_called_with?(args)
-      return @called_args == args
+      ArgMatchFactory.create_arg_matcher_using(args).matches?(@called_args)
     end
 
     def process

data/lib/core/arg_matching/arg_match_factory.rb

@@ -0,0 +1,12 @@
+module Fakes
+  class ArgMatchFactory
+    def self.create_arg_matcher_using(args)
+      matcher = CombinedArgMatcher.new      
+      args.each do|arg|
+        current_matcher = arg.respond_to?(:is_used_in_the_arg_matching_process?) ? arg : RegularArgMatcher.new(arg)
+        matcher.add current_matcher
+      end
+      matcher
+    end
+  end
+end

data/lib/core/arg_matching/arg_match_protocol.rb

@@ -0,0 +1,6 @@
+module Fakes
+  module ArgMatchProtocol
+    def is_used_in_the_arg_matching_process?
+    end
+  end
+end

data/lib/core/arg_matching/block_arg_matcher.rb

@@ -0,0 +1,14 @@
+module Fakes
+  class BlockArgMatcher
+    include ArgMatchProtocol
+
+    def initialize(specification_block)
+      @specification_block = specification_block
+    end
+
+    def matches?(item)
+      @specification_block.call(item)
+    end
+  
+  end
+end

data/lib/core/arg_matching/combined_arg_matcher.rb

@@ -0,0 +1,24 @@
+module Fakes
+  class CombinedArgMatcher
+    include ArgMatchProtocol
+    attr_reader :all_matchers
+
+    def initialize(options = {})
+      @all_matchers = options.fetch(:matchers,[])
+    end
+
+    def matches?(args)
+      matches = true
+      for index in 0..@all_matchers.count - 1
+        matches &= @all_matchers[index].matches?(args[index])
+        return false unless matches
+      end
+      matches
+    end
+
+    def add(matcher)
+      @all_matchers << matcher
+    end
+    
+  end
+end

data/lib/core/arg_matching/matches.rb

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

data/lib/core/arg_matching/regular_arg_matcher.rb

@@ -0,0 +1,13 @@
+module Fakes
+  class RegularArgMatcher
+    include ArgMatchProtocol
+
+    def initialize(value_to_match)
+      @value_to_match = value_to_match
+    end
+
+    def matches?(item)
+      @value_to_match == item
+    end
+  end
+end

data/lib/core/arg_set.rb

@@ -3,7 +3,7 @@ module Fakes
     include ArgBehaviour
 
     def initialize(args)
-      @args = args
+      initialize_matcher_using(args)
       @times_called = 0
     end
   end

data/lib/core/ignore_set.rb

@@ -16,9 +16,9 @@ module Fakes
       return true
     end
 
-
     def was_called_with?(args)
-      return @arg_sets.select{|set| set == args}.count > 0
+      matcher = ArgMatchFactory.create_arg_matcher_using(args)
+      return @arg_sets.select{|set| matcher.matches?(set)}.count > 0
     end
   end
 end

data/lib/core/version.rb

@@ -1,3 +1,3 @@
 module Fakes
-  VERSION = "0.2.3"
+  VERSION = "0.3.0"
 end

data/lib/fakes.rb

@@ -1,5 +1,11 @@
 require 'developwithpassion_arrays'
 
+require 'core/arg_matching/arg_match_factory'
+require 'core/arg_matching/arg_match_protocol'
+require 'core/arg_matching/block_arg_matcher'
+require 'core/arg_matching/combined_arg_matcher'
+require 'core/arg_matching/matches'
+require 'core/arg_matching/regular_arg_matcher'
 require 'core/arg_behaviour'
 require 'core/arg_set'
 require 'core/fake'

data/spec/specs/arg_behaviour_spec.rb

@@ -48,34 +48,36 @@ module Fakes
         sut.called_args.should == 2
       end
     end
-
+    
     context "when matching a set of arguments" do
+      let(:matcher){Object.new}
       before (:each) do
-        sut.args = 2
+        sut.arg_matcher = matcher
+
+        matcher.stub(:matches?).with(2).and_return(true)
+        matcher.stub(:matches?).with(3).and_return(false)
       end
-      it "should match if its own set of arguments are the same" do
+      it "should match if its argument matcher matches the argument set" do
         sut.matches?(2).should be_true
         sut.matches?(3).should be_false
       end
     end
 
-    context "when matching a set of arguments that is passed in as a dictionary" do
-      before (:each) do
-        sut.args = {:id => 0,:name => "JP"}
-      end
-      it "should match if its hash is the same" do
-        sut.matches?(:id => 0,:name => "JP").should be_true
-      end
-    end
 
     context "when determining whether it was called with a set of arguments" do
+      let(:the_matcher){Object.new}
+
+      before (:each) do
+        ArgMatchFactory.stub(:create_arg_matcher_using).with(2).and_return(the_matcher)
+        the_matcher.stub(:matches?).with(2).and_return(true)
+      end
+      
       before (:each) do
         sut.called_args = 2
       end
 
-      it "should match if the arguments are the same as the arguments it was invoked with" do
+      it "should make the decision by using the matcher created to match the arguments" do
         sut.was_called_with?(2).should be_true
-        sut.was_called_with?(3).should be_false
       end
     end
   end

data/spec/specs/arg_match_factory_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+module Fakes
+  describe ArgMatchFactory do
+    context "when creating an argument matcher" do
+      context "and none of the arguments are matchers themselves" do
+        before (:each) do
+          @result = ArgMatchFactory.create_arg_matcher_using([2,3,4])
+        end
+        
+        it "should create a combined matcher that is composed of regular matchers" do
+          @result.all_matchers.count.should == 3
+          @result.all_matchers.each do|matcher|
+            matcher.class.should == RegularArgMatcher
+          end
+        end
+      end
+      context "and the arguments are matchers themselves" do
+        let(:matcher){Object.new}
+        before (:each) do
+          matcher.stub(:respond_to?).with(:is_used_in_the_arg_matching_process?).and_return(true)
+        end
+        
+        before (:each) do
+          @result = ArgMatchFactory.create_arg_matcher_using([matcher])
+        end
+        
+        it "should create a combined matcher that only using the matchers provided" do
+          @result.all_matchers.count.should == 1
+          @result.all_matchers[0].should == matcher
+        end
+      end
+    end
+  end
+end

data/spec/specs/arg_matching_scenarios_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+module Fakes
+  describe "Arg matching scenarios" do
+    it "should be able to intercept using argument matchers" do
+      fake = Fake.new
+
+      fake.hello("World")
+
+      fake.received(:hello).called_with(Matches.any).should_not be_nil
+    end
+
+    it "should be able to intercept using greater than matchers" do
+      fake = Fake.new
+
+      fake.hello(10)
+
+      fake.received(:hello).called_with(Matches.greater_than(2)).should_not be_nil
+    end
+
+    it "should be able to intercept using regex matchers" do
+      fake = Fake.new
+
+      fake.hello("This is cool")
+
+      fake.received(:hello).called_with(Matches.regex(/is/)).should_not be_nil
+    end
+
+    it "should be able to intercept using range matchers" do
+      fake = Fake.new
+
+      fake.hello(7)
+
+      fake.received(:hello).called_with(Matches.in_range(4..8)).should_not be_nil
+    end
+
+    it "should be able to intercept using conditional matchers" do
+      fake = Fake.new
+
+      fake.hello(7)
+
+      fake.received(:hello).called_with(Matches.condition(lambda{|item| item < 10})).should_not be_nil
+    end
+
+    it "should be able to intercept by mixing regular arguments with matchers" do
+      fake = Fake.new
+
+      fake.hello(7,4,"Yes")
+
+      fake.received(:hello).called_with(7,Matches.greater_than(2),Matches.regex(/Y/)).should_not be_nil
+      fake.received(:hello).called_with(7,Matches.any,Matches.regex(/Y/)).should_not be_nil
+      fake.received(:hello).called_with(7,Matches.any,"Yes").should_not be_nil
+      fake.received(:hello).called_with(6,Matches.any,"Yes").should be_nil
+    end
+  end
+
+end

data/spec/specs/arg_set_spec.rb

@@ -3,11 +3,14 @@ require 'spec_helper'
 module Fakes
   describe ArgSet do
     context "when created" do
-      let(:sut){ArgSet.new(1)}
+      let(:sut){ArgSet.new([1])}
 
+      
       it "should initialize required members" do
         sut.times_called.should == 0
       end
+
     end
+
   end
 end

data/spec/specs/block_arg_matcher_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+module Fakes
+  describe BlockArgMatcher do
+    context "when determining if it matches a value" do
+      let(:sut){BlockArgMatcher.new(lambda{|item| true})}
+      
+      it "should decide by using its provided block" do
+        sut.matches?(2).should be_true
+      end
+    end
+  end
+  
+end

data/spec/specs/combined_arg_matcher_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+module Fakes
+  describe CombinedArgMatcher do
+    context "when determining whether it matches an set of arguments" do
+      let(:args){[2,3]}
+      let(:first_matcher){Object.new}
+      let(:second_matcher){Object.new}
+      let(:matchers){[first_matcher,second_matcher]}
+      let(:options){{:matchers => matchers}}
+      let(:sut){CombinedArgMatcher.new(options)}
+      before (:each) do
+        first_matcher.stub(:matches?).with(2).and_return(3)
+        second_matcher.stub(:matches?).with(3).and_return(3)
+      end
+      
+      
+      before (:each) do
+        @result = sut.matches?(args)
+      end
+      
+      
+      it "should match if each of its argument matchers matches its respective argument" do
+        @result.should be_true
+      end
+    end
+    context "when adding a matcher" do
+      let(:first_matcher){Object.new}
+      let(:matchers){[]}
+      let(:options){{:matchers => matchers}}
+      let(:sut){CombinedArgMatcher.new(options)}
+      
+      before (:each) do
+        sut.add(first_matcher)
+      end
+      
+      
+      it "should add the matcher to its set of matchers" do
+        matchers[0].should == first_matcher
+      end
+    end
+  end
+end
+

data/spec/specs/fake_spec.rb

@@ -135,6 +135,22 @@ module Fakes
     end
 
     context "scenarios" do
+      context "setting up return values using argument matchers" do
+        it "should be able to intercept on methods using the matches factory" do
+          fake = Fake.new
+
+          fake.stub(:hello).with(Matches.regex(/W/)).and_return("Hello World") 
+          fake.hello("World").should == "Hello World"
+        end
+        it "should be able to intercept on methods using combinations of explicit values and matchers" do
+          fake = Fake.new
+
+          fake.stub(:hello).with(Matches.regex(/W/),Matches.greater_than(3),10).and_return("Hello World") 
+
+          fake.hello("World",4,10).should == "Hello World"
+          fake.hello("World",2,10).should == nil
+        end
+      end
       context "setting up return values" do
         it "should be able to intercept on methods that take a singular value" do
           fake = Fake.new
@@ -214,6 +230,7 @@ module Fakes
           fake.received(:hello).called_with(1,[1,2,3,4]).should_not be_nil
           fake.received(:hello).called_with(1,[1,2,3,5]).should be_nil
         end
+
       end
     end
   end

data/spec/specs/ignore_set_spec.rb

@@ -28,11 +28,20 @@ module Fakes
     end
 
     context "when determining if it was called with a set of arguments" do
+      let(:the_matcher){Object.new}
+
+      before (:each) do
+        ArgMatchFactory.stub(:create_arg_matcher_using).with(2).and_return(the_matcher)
+        the_matcher.stub(:matches?).with(3).and_return(true)
+        the_matcher.stub(:matches?).with(1).and_return(true)
+      end
+      
       before (:each) do
         sut.capture_args(1)
-        sut.capture_args(2)
+        sut.capture_args(3)
       end
-      it "should match if any of its argument sets match" do
+
+      it "should make the decision by using the matcher created to match the argument sets that were stored" do
         sut.was_called_with?(2).should be_true
       end
     end

data/spec/specs/matches_spec.rb

@@ -0,0 +1,36 @@
+module Fakes
+  describe Matches do
+    context "when creating matchers" do
+      it "should be able to create a matcher that matches anything" do
+        (1..10).each{|item| Matches.any.matches?(item).should be_true}
+      end
+      it "should be able to create a numeric greater than matcher" do
+        match = Matches.greater_than(5)
+        match.matches?(4).should be_false
+        match.matches?(5).should be_false
+        match.matches?(6).should be_true
+        
+      end
+      it "should be able to create a range matcher" do
+        match = Matches.in_range((1..10))
+        match.matches?(4).should be_true
+        match.matches?(10).should be_true
+        match.matches?(11).should be_false
+      end
+      it "should be able to create a regex string matcher" do
+        match = Matches.regex(/a|e|i|o|u/)
+        match.matches?("awwef").should be_true
+        match.matches?("rwwgf").should be_false
+      end
+
+      it "should be able to create a lambda based matcher" do
+        match = Matches.condition(lambda{|item| item > 3})
+        match.matches?(2).should be_false
+        match.matches?(7).should be_true
+      end
+    end
+    
+    
+  end
+  
+end

data/spec/specs/regular_arg_matcher_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+module Fakes
+  describe RegularArgMatcher do
+    context "when determining if it matches a value" do
+      let(:sut){RegularArgMatcher.new(2)}
+      
+      it "should match if the incoming value matches the value it was created to match" do
+        sut.matches?(2).should be_true
+        sut.matches?(3).should be_false
+      end
+    end
+  end
+  
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fakes
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-31 00:00:00.000000000 Z
+date: 2012-06-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -108,6 +108,12 @@ files:
 - Rakefile
 - fakes.gemspec
 - lib/core/arg_behaviour.rb
+- lib/core/arg_matching/arg_match_factory.rb
+- lib/core/arg_matching/arg_match_protocol.rb
+- lib/core/arg_matching/block_arg_matcher.rb
+- lib/core/arg_matching/combined_arg_matcher.rb
+- lib/core/arg_matching/matches.rb
+- lib/core/arg_matching/regular_arg_matcher.rb
 - lib/core/arg_set.rb
 - lib/core/fake.rb
 - lib/core/ignore_set.rb
@@ -116,11 +122,17 @@ files:
 - lib/fakes.rb
 - spec/spec_helper.rb
 - spec/specs/arg_behaviour_spec.rb
+- spec/specs/arg_match_factory_spec.rb
+- spec/specs/arg_matching_scenarios_spec.rb
 - spec/specs/arg_set_spec.rb
+- spec/specs/block_arg_matcher_spec.rb
+- spec/specs/combined_arg_matcher_spec.rb
 - spec/specs/fake_spec.rb
 - spec/specs/ignore_set_spec.rb
 - spec/specs/kernel_spec.rb
+- spec/specs/matches_spec.rb
 - spec/specs/method_stub_spec.rb
+- spec/specs/regular_arg_matcher_spec.rb
 homepage: http://www.developwithpassion.com
 licenses: []
 post_install_message: 
@@ -148,8 +160,14 @@ summary: Simple faking library
 test_files:
 - spec/spec_helper.rb
 - spec/specs/arg_behaviour_spec.rb
+- spec/specs/arg_match_factory_spec.rb
+- spec/specs/arg_matching_scenarios_spec.rb
 - spec/specs/arg_set_spec.rb
+- spec/specs/block_arg_matcher_spec.rb
+- spec/specs/combined_arg_matcher_spec.rb
 - spec/specs/fake_spec.rb
 - spec/specs/ignore_set_spec.rb
 - spec/specs/kernel_spec.rb
+- spec/specs/matches_spec.rb
 - spec/specs/method_stub_spec.rb
+- spec/specs/regular_arg_matcher_spec.rb