rspec 1.3.2 → 2.0.0.a2

data/spec/spec/mocks/bug_report_7611_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-
-module Bug7611
-  class Foo
-  end
-
-  class Bar < Foo
-  end
-
-  describe "A Partial Mock" do
-    it "should respect subclasses" do
-      Foo.stub!(:new).and_return(Object.new)
-    end
-
-    it "should" do
-      Bar.new.class.should == Bar
-    end 
-  end
-end

data/spec/spec/mocks/bug_report_7805_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-module Bug7805
-  #This is really a duplicate of 8302
-
-  describe "Stubs should correctly restore module methods" do
-    it "1 - stub the open method" do
-      File.stub!(:open).and_return("something")
-      File.open.should == "something"
-    end
-    it "2 - use File.open to create example.txt" do
-      filename = "#{File.dirname(__FILE__)}/example-#{Time.new.to_i}.txt"
-      File.exist?(filename).should be_false
-      file = File.open(filename,'w')
-      file.close
-      File.exist?(filename).should be_true
-      File.delete(filename)
-      File.exist?(filename).should be_false
-    end
-  end
-
-end

data/spec/spec/mocks/bug_report_8165_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-describe "An object where respond_to? is true and does not have method" do
-  # When should_receive(:sym) is sent to any object, the Proxy sends
-  # respond_to?(:sym) to that object to see if the method should be proxied.
-  #
-  # If respond_to? itself is proxied, then when the Proxy sends respond_to?
-  # to the object, the proxy is invoked and responds yes (if so set in the spec).
-  # When the object does NOT actually respond to :sym, an exception is thrown
-  # when trying to proxy it.
-  #
-  # The fix was to keep track of whether :respond_to? had been proxied and, if
-  # so, call the munged copy of :respond_to? on the object.
-
-  it "should not raise an exception for Object" do
-    obj = Object.new
-    obj.should_receive(:respond_to?).with(:foobar).and_return(true)
-    obj.should_receive(:foobar).and_return(:baz)
-    obj.respond_to?(:foobar).should be_true
-    obj.foobar.should == :baz
-  end
-
-  it "should not raise an exception for mock" do
-    obj = mock("obj")
-    obj.should_receive(:respond_to?).with(:foobar).and_return(true)
-    obj.should_receive(:foobar).and_return(:baz)
-    obj.respond_to?(:foobar).should be_true
-    obj.foobar.should == :baz
-  end
-
-end

data/spec/spec/mocks/bug_report_8302_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-module Bug8302
-  class Foo
-    def Foo.class_method(arg)
-    end
-  
-    def instance_bar(arg)
-    end
-  end
-
-  describe "Bug report 8302:" do
-    it "class method is not restored correctly when proxied" do
-      Foo.should_not_receive(:class_method).with(Array.new)
-      Foo.rspec_verify
-      Foo.class_method(Array.new)
-    end
-
-    it "instance method is not restored correctly when proxied" do
-      foo = Foo.new
-      foo.should_not_receive(:instance_bar).with(Array.new)
-      foo.rspec_verify
-      foo.instance_bar(Array.new)
-    end
-  end
-end

data/spec/spec/mocks/bug_report_830_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-module Spec
-  module Mocks
-    describe 'Calling a method that catches StandardError' do
-      class Foo
-        def self.foo
-          bar
-        rescue StandardError
-        end
-      end
-
-      it 'still reports mock failures' do
-        Foo.should_not_receive :bar
-        lambda do
-          Foo.foo
-        end.should raise_error(MockExpectationError)
-      end
-    end
-  end
-end

data/spec/spec/mocks/bug_report_957_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-module Spec
-  module Mocks
-    describe "stubbing a base class class method" do
-      before do
-        @base_class     = Class.new
-        @concrete_class = Class.new(@base_class)
-
-        @base_class.stub!(:find).and_return "stubbed_value"
-      end
-
-      it "should return the value for the stub on the base class" do
-        @base_class.find.should == "stubbed_value"
-      end
-
-      it "should return the value for the descendent class" do
-        @concrete_class.find.should == "stubbed_value"
-      end
-    end
-  end
-end

data/spec/spec/mocks/double_spec.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-
-describe "double" do
-  it "is an alias for stub and mock" do
-    double().should be_a(Spec::Mocks::Mock)
-  end
-  
-  it "uses 'Double' in failure messages" do
-    double = double('name')
-    expect {double.foo}.to raise_error(/Double "name" received/)
-  end
-end

data/spec/spec/mocks/failing_argument_matchers_spec.rb

@@ -1,95 +0,0 @@
-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

@@ -1,90 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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,94 +0,0 @@
-require 'spec_helper'
-
-module Spec
-  module Mocks
-
-    describe "Mock ordering" do
-
-      before do
-        @mock = mock("test mock")
-      end
-      
-      after do
-        @mock.rspec_reset
-      end
-
-      it "should pass two calls in order" do
-        @mock.should_receive(:one).ordered
-        @mock.should_receive(:two).ordered
-        @mock.one
-        @mock.two
-        @mock.rspec_verify
-      end
-
-      it "should pass three calls in order" do
-        @mock.should_receive(:one).ordered
-        @mock.should_receive(:two).ordered
-        @mock.should_receive(:three).ordered
-        @mock.one
-        @mock.two
-        @mock.three
-        @mock.rspec_verify
-      end
-
-      it "should fail if second call comes first" do
-        @mock.should_receive(:one).ordered
-        @mock.should_receive(:two).ordered
-        lambda do
-          @mock.two
-        end.should raise_error(MockExpectationError, "Mock \"test mock\" received :two out of order")
-      end
-
-      it "should fail if third call comes first" do
-        @mock.should_receive(:one).ordered
-        @mock.should_receive(:two).ordered
-        @mock.should_receive(:three).ordered
-        @mock.one
-        lambda do
-          @mock.three
-        end.should raise_error(MockExpectationError, "Mock \"test mock\" received :three out of order")
-      end
-      
-      it "should fail if third call comes second" do
-        @mock.should_receive(:one).ordered
-        @mock.should_receive(:two).ordered
-        @mock.should_receive(:three).ordered
-        @mock.one
-        lambda do
-          @mock.three
-        end.should raise_error(MockExpectationError, "Mock \"test mock\" received :three out of order")
-      end
-
-      it "should ignore order of non ordered calls" do
-        @mock.should_receive(:ignored_0)
-        @mock.should_receive(:ordered_1).ordered
-        @mock.should_receive(:ignored_1)
-        @mock.should_receive(:ordered_2).ordered
-        @mock.should_receive(:ignored_2)
-        @mock.should_receive(:ignored_3)
-        @mock.should_receive(:ordered_3).ordered
-        @mock.should_receive(:ignored_4)
-        @mock.ignored_3
-        @mock.ordered_1
-        @mock.ignored_0
-        @mock.ordered_2
-        @mock.ignored_4
-        @mock.ignored_2
-        @mock.ordered_3
-        @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