rspec 1.0.0 → 1.3.1

data/spec/spec/mocks/failing_argument_matchers_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+module Spec
+  module Mocks
+    describe "failing MockArgumentMatchers" do
+      before(:each) do
+        @mock = mock("test mock")
+        @reporter = Mock.new("reporter", :null_object => true)
+      end
+      
+      after(:each) do
+        @mock.rspec_reset
+      end
+
+      it "should reject non boolean" do
+        @mock.should_receive(:random_call).with(boolean())
+        lambda do
+          @mock.random_call("false")
+        end.should raise_error(MockExpectationError)
+      end
+
+      it "should reject non numeric" do
+        @mock.should_receive(:random_call).with(an_instance_of(Numeric))
+        lambda do
+          @mock.random_call("1")
+        end.should raise_error(MockExpectationError)
+      end
+      
+      it "should reject non string" do
+        @mock.should_receive(:random_call).with(an_instance_of(String))
+        lambda do
+          @mock.random_call(123)
+        end.should raise_error(MockExpectationError)
+      end
+      
+      it "should reject goose when expecting a duck" do
+        @mock.should_receive(:random_call).with(duck_type(:abs, :div))
+        lambda { @mock.random_call("I don't respond to :abs or :div") }.should raise_error(MockExpectationError)
+      end
+
+      it "should fail if regexp does not match submitted string" do
+        @mock.should_receive(:random_call).with(/bcd/)
+        lambda { @mock.random_call("abc") }.should raise_error(MockExpectationError)
+      end
+      
+      it "should fail if regexp does not match submitted regexp" do
+        @mock.should_receive(:random_call).with(/bcd/)
+        lambda { @mock.random_call(/bcde/) }.should raise_error(MockExpectationError)
+      end
+      
+      it "should fail for a hash w/ wrong values" do
+        @mock.should_receive(:random_call).with(:a => "b", :c => "d")
+        lambda do
+          @mock.random_call(:a => "b", :c => "e")
+        end.should raise_error(MockExpectationError, /Mock "test mock" received :random_call with unexpected arguments\n  expected: \(\{(:a=>\"b\", :c=>\"d\"|:c=>\"d\", :a=>\"b\")\}\)\n       got: \(\{(:a=>\"b\", :c=>\"e\"|:c=>\"e\", :a=>\"b\")\}\)/)
+      end
+      
+      it "should fail for a hash w/ wrong keys" do
+        @mock.should_receive(:random_call).with(:a => "b", :c => "d")
+        lambda do
+          @mock.random_call("a" => "b", "c" => "d")
+        end.should raise_error(MockExpectationError, /Mock "test mock" received :random_call with unexpected arguments\n  expected: \(\{(:a=>\"b\", :c=>\"d\"|:c=>\"d\", :a=>\"b\")\}\)\n       got: \(\{(\"a\"=>\"b\", \"c\"=>\"d\"|\"c\"=>\"d\", \"a\"=>\"b\")\}\)/)
+      end
+      
+      it "should match against a Matcher" do
+        lambda do
+          @mock.should_receive(:msg).with(equal(3))
+          @mock.msg(37)
+        end.should raise_error(MockExpectationError, "Mock \"test mock\" received :msg with unexpected arguments\n  expected: (equal 3)\n       got: (37)")
+      end
+      
+      it "should fail no_args with one arg" do
+        lambda do
+          @mock.should_receive(:msg).with(no_args)
+          @mock.msg(37)
+        end.should raise_error(MockExpectationError, "Mock \"test mock\" received :msg with unexpected arguments\n  expected: (no args)\n       got: (37)")
+      end
+      
+      it "should fail hash_including with missing key" do
+         lambda do
+           @mock.should_receive(:msg).with(hash_including(:a => 1))
+           @mock.msg({})
+         end.should raise_error(MockExpectationError, "Mock \"test mock\" received :msg with unexpected arguments\n  expected: (hash_including(:a=>1))\n       got: ({})")
+      end
+
+      it "should fail with block matchers" do
+        lambda do
+          @mock.should_receive(:msg).with {|arg| arg.should == :received }
+          @mock.msg :no_msg_for_you
+        end.should raise_error(Spec::Expectations::ExpectationNotMetError, /expected: :received.*\s*.*got: :no_msg_for_you/)
+      end
+            
+    end
+  end
+end

data/spec/spec/mocks/hash_including_matcher_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+module Spec
+  module Mocks
+    module ArgumentMatchers
+      describe HashIncludingMatcher do
+        
+        it "should describe itself properly" do
+          HashIncludingMatcher.new(:a => 1).description.should == "hash_including(:a=>1)"
+        end      
+
+        describe "passing" do
+          it "should match the same hash" do
+            hash_including(:a => 1).should == {:a => 1}
+          end
+
+          it "should match a hash with extra stuff" do
+            hash_including(:a => 1).should == {:a => 1, :b => 2}
+          end
+          
+          describe "when matching against other matchers" do
+            it "should match an int against anything()" do
+              hash_including(:a => anything, :b => 2).should == {:a => 1, :b => 2}
+            end
+
+            it "should match a string against anything()" do
+              hash_including(:a => anything, :b => 2).should == {:a => "1", :b => 2}
+            end
+          end
+          
+          describe "when passed only keys or keys mixed with key/value pairs" do
+            it "should match if the key is present" do
+              hash_including(:a).should == {:a => 1, :b => 2}
+            end
+            
+            it "should match if more keys are present" do
+              hash_including(:a, :b).should == {:a => 1, :b => 2, :c => 3}
+            end
+
+            it "should match a string against a given key" do
+              hash_including(:a).should == {:a => "1", :b => 2}
+            end
+
+            it "should match if passed one key and one key/value pair" do
+              hash_including(:a, :b => 2).should == {:a => 1, :b => 2}
+            end
+            
+            it "should match if passed many keys and one key/value pair" do
+              hash_including(:a, :b, :c => 3).should == {:a => 1, :b => 2, :c => 3, :d => 4}
+            end
+            
+            it "should match if passed many keys and many key/value pairs" do
+              hash_including(:a, :b, :c => 3, :e => 5).should == {:a => 1, :b => 2, :c => 3, :d => 4, :e => 5}
+            end
+          end
+        end
+        
+        describe "failing" do
+          it "should not match a non-hash" do
+            hash_including(:a => 1).should_not == 1
+          end
+
+          it "should not match a hash with a missing key" do
+            hash_including(:a => 1).should_not == {:b => 2}
+          end
+          
+          it "should not match a hash with a missing key" do
+            hash_including(:a).should_not == {:b => 2}
+          end
+          
+          it "should not match an empty hash with a given key" do
+            hash_including(:a).should_not == {}
+          end
+          
+          it "should not match a hash with a missing key when one pair is matching" do
+            hash_including(:a, :b => 2).should_not == {:b => 2}
+          end
+          
+          it "should not match a hash with an incorrect value" do
+            hash_including(:a => 1, :b => 2).should_not == {:a => 1, :b => 3}
+          end
+
+          it "should not match when values are nil but keys are different" do
+            hash_including(:a => nil).should_not == {:b => nil}
+          end
+        end
+      end
+    end
+  end
+end

data/spec/spec/mocks/hash_not_including_matcher_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+module Spec
+  module Mocks
+    module ArgumentMatchers
+      describe HashNotIncludingMatcher do
+        
+        it "should describe itself properly" do
+          HashNotIncludingMatcher.new(:a => 5).description.should == "hash_not_including(:a=>5)"
+        end      
+
+        describe "passing" do
+          it "should match a hash without the specified key" do
+            hash_not_including(:c).should == {:a => 1, :b => 2}
+          end
+          
+          it "should match a hash with the specified key, but different value" do
+            hash_not_including(:b => 3).should == {:a => 1, :b => 2}
+          end
+                    
+          it "should match a hash without the specified key, given as anything()" do
+            hash_not_including(:c => anything).should == {:a => 1, :b => 2}
+          end
+
+          it "should match an empty hash" do
+            hash_not_including(:a).should == {}
+          end
+          
+          it "should match a hash without any of the specified keys" do
+            hash_not_including(:a, :b, :c).should == { :d => 7}
+          end
+          
+        end
+        
+        describe "failing" do
+          it "should not match a non-hash" do
+            hash_not_including(:a => 1).should_not == 1
+          end
+          
+          it "should not match a hash with a specified key" do
+            hash_not_including(:b).should_not == {:b => 2}
+          end
+          
+          it "should not match a hash with the specified key/value pair" do
+            hash_not_including(:b => 2).should_not == {:a => 1, :b => 2}
+          end
+          
+          it "should not match a hash with the specified key" do
+            hash_not_including(:a, :b => 3).should_not == {:a => 1, :b => 2}
+          end
+          
+          it "should not match a hash with one of the specified keys" do
+            hash_not_including(:a, :b).should_not == {:b => 2}
+          end
+          
+          it "should not match a hash with some of the specified keys" do
+            hash_not_including(:a, :b, :c).should_not == {:a => 1, :b => 2}
+          end
+          
+          it "should not match a hash with one key/value pair included" do
+            hash_not_including(:a, :b, :c, :d => 7).should_not == { :d => 7}
+          end
+        end
+      end
+    end
+  end
+end

data/spec/spec/mocks/mock_ordering_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
+require 'spec_helper'
 
 module Spec
   module Mocks
@@ -36,7 +36,7 @@ module Spec
         @mock.should_receive(:two).ordered
         lambda do
           @mock.two
-        end.should raise_error(MockExpectationError, "Mock 'test mock' received :two out of order")
+        end.should raise_error(MockExpectationError, "Mock \"test mock\" received :two out of order")
       end
 
       it "should fail if third call comes first" do
@@ -46,7 +46,7 @@ module Spec
         @mock.one
         lambda do
           @mock.three
-        end.should raise_error(MockExpectationError, "Mock 'test mock' received :three out of order")
+        end.should raise_error(MockExpectationError, "Mock \"test mock\" received :three out of order")
       end
       
       it "should fail if third call comes second" do
@@ -56,7 +56,7 @@ module Spec
         @mock.one
         lambda do
           @mock.three
-        end.should raise_error(MockExpectationError, "Mock 'test mock' received :three out of order")
+        end.should raise_error(MockExpectationError, "Mock \"test mock\" received :three out of order")
       end
 
       it "should ignore order of non ordered calls" do
@@ -78,7 +78,17 @@ module Spec
         @mock.ignored_1
         @mock.rspec_verify
       end
+      
+      it "should pass when duplicates exist" do
+        @mock.should_receive(:a).ordered
+        @mock.should_receive(:b).ordered
+        @mock.should_receive(:a).ordered
+        
+        @mock.a
+        @mock.b
+        @mock.a
+      end
             
     end
   end
-end
+end

data/spec/spec/mocks/mock_space_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
+require 'spec_helper'
 require 'spec/mocks'
 
 module Spec