rspec-mocks 2.0.0.beta.4 → 2.0.0.beta.5

data/spec/rspec/mocks/bug_report_10260_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe "An RSpec Mock" do
   it "should hide internals in its inspect representation" do
-    m = mock('cup')
+    m = double('cup')
     m.inspect.should =~ /#<Rspec::Mocks::Mock:0x[a-f0-9.]+ @name="cup">/
   end
 end

data/spec/rspec/mocks/bug_report_10263_spec.rb

@@ -1,26 +1,26 @@
 describe "Mock" do
   before do
-    @mock = mock("test mock")
+    @double = double("test double")
   end
   
   specify "when one example has an expectation (non-mock) inside the block passed to the mock" do
-    @mock.should_receive(:msg) do |b|
+    @double.should_receive(:msg) do |b|
       b.should be_true #this call exposes the problem
     end
     begin
-      @mock.msg(false)
+      @double.msg(false)
     rescue Exception
     end
   end
   
   specify "then the next example should behave as expected instead of saying" do
-    @mock.should_receive(:foobar)
-    @mock.foobar
-    @mock.rspec_verify
+    @double.should_receive(:foobar)
+    @double.foobar
+    @double.rspec_verify
     begin
-      @mock.foobar
+      @double.foobar
     rescue Exception => e
-      e.message.should == "Mock 'test mock' received unexpected message :foobar with (no args)"
+      e.message.should == "Double \"test double\" received unexpected message :foobar with (no args)"
     end
   end 
 end

data/spec/rspec/mocks/bug_report_15719_spec.rb

@@ -5,25 +5,25 @@ module Rspec
     describe "mock failure" do
       
       it "should tell you when it receives the right message with the wrong args" do
-        m = mock("foo")
-        m.should_receive(:bar).with("message")
+        double = double("foo")
+        double.should_receive(:bar).with("message")
         lambda {
-          m.bar("different message")
-        }.should raise_error(Rspec::Mocks::MockExpectationError, %Q{Mock 'foo' expected :bar with ("message") but received it with ("different message")})
-        m.bar("message") # allows the spec to pass
+          double.bar("different message")
+        }.should raise_error(Rspec::Mocks::MockExpectationError, %Q{Double "foo" received :bar with unexpected arguments\n  expected: ("message")\n       got: ("different message")})
+        double.rspec_reset # so the example doesn't fail
       end
 
       pending "should tell you when it receives the right message with the wrong args if you stub the method (fix bug 15719)" do
         # NOTE - for whatever reason, if you use a the block style of pending here,
         # rcov gets unhappy. Don't know why yet.
-        m = mock("foo")
-        m.stub!(:bar)
-        m.should_receive(:bar).with("message")
+        double = double("foo")
+        double.stub(:bar)
+        double.should_receive(:bar).with("message")
         lambda {
-          m.bar("different message")
-        }.should raise_error(Rspec::Mocks::MockExpectationError, %Q{Mock 'foo' expected :bar with ("message") but received it with ("different message")})
-        m.bar("message") # allows the spec to pass
+          double.bar("different message")
+        }.should raise_error(Rspec::Mocks::MockExpectationError, %Q{Double 'foo' expected :bar with ("message") but received it with ("different message")})
+        double.rspec_reset # so the example doesn't fail
       end
     end
   end
-end
+end

data/spec/rspec/mocks/bug_report_7611_spec.rb

@@ -8,7 +8,7 @@ module Bug7611
     class Bar < Foo
     end
     it "should respect subclasses" do
-      Foo.stub!(:new).and_return(Object.new)
+      Foo.stub(:new).and_return(Object.new)
     end
 
     it "should" do

data/spec/rspec/mocks/bug_report_7805_spec.rb

@@ -5,7 +5,7 @@ module Bug7805
 
   describe "Stubs should correctly restore module methods" do
     it "1 - stub the open method" do
-      File.stub!(:open).and_return("something")
+      File.stub(:open).and_return("something")
       File.open.should == "something"
     end
     it "2 - use File.open to create example.txt" do

data/spec/rspec/mocks/bug_report_8165_spec.rb

@@ -21,7 +21,7 @@ describe "An object where respond_to? is true and does not have method" do
   end
 
   it "should not raise an exception for mock" do
-    obj = mock("obj")
+    obj = double("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

data/spec/rspec/mocks/bug_report_957_spec.rb

@@ -7,7 +7,7 @@ module Spec
         @base_class     = Class.new
         @concrete_class = Class.new(@base_class)
 
-        @base_class.stub!(:find).and_return "stubbed_value"
+        @base_class.stub(:find).and_return "stubbed_value"
       end
 
       it "should return the value for the stub on the base class" do

data/spec/rspec/mocks/double_spec.rb

@@ -0,0 +1,12 @@
+require "spec_helper"
+
+describe "double" do
+  it "is an alias for stub and mock" do
+    double().should be_a(Rspec::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/rspec/mocks/failing_argument_matchers_spec.rb

@@ -4,7 +4,7 @@ module Rspec
   module Mocks
     describe "failing MockArgumentMatchers" do
       before(:each) do
-        @mock = mock("test mock")
+        @mock = double("test double")
         @reporter = Rspec::Mocks::Mock.new("reporter", :null_object => true)
       end
       
@@ -52,35 +52,35 @@ module Rspec
         @mock.should_receive(:random_call).with(:a => "b", :c => "d")
         lambda do
           @mock.random_call(:a => "b", :c => "e")
-        end.should raise_error(Rspec::Mocks::MockExpectationError, /Mock 'test mock' expected :random_call with \(\{(:a=>\"b\", :c=>\"d\"|:c=>\"d\", :a=>\"b\")\}\) but received it with \(\{(:a=>\"b\", :c=>\"e\"|:c=>\"e\", :a=>\"b\")\}\)/)
+        end.should raise_error(Rspec::Mocks::MockExpectationError, /Double "test double" 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(Rspec::Mocks::MockExpectationError, /Mock 'test mock' expected :random_call with \(\{(:a=>\"b\", :c=>\"d\"|:c=>\"d\", :a=>\"b\")\}\) but received it with \(\{(\"a\"=>\"b\", \"c\"=>\"d\"|\"c\"=>\"d\", \"a\"=>\"b\")\}\)/)
+        end.should raise_error(Rspec::Mocks::MockExpectationError, /Double "test double" 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(Rspec::Mocks::MockExpectationError, "Mock 'test mock' expected :msg with (equal 3) but received it with (37)")
+        end.should raise_error(Rspec::Mocks::MockExpectationError, "Double \"test double\" 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(Rspec::Mocks::MockExpectationError, "Mock 'test mock' expected :msg with (no args) but received it with (37)")
+        end.should raise_error(Rspec::Mocks::MockExpectationError, "Double \"test double\" 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(Rspec::Mocks::MockExpectationError, "Mock 'test mock' expected :msg with (hash_including(:a=>1)) but received it with ({})")
+         end.should raise_error(Rspec::Mocks::MockExpectationError, "Double \"test double\" received :msg with unexpected arguments\n  expected: (hash_including(:a=>1))\n       got: ({})")
       end
 
       it "should fail with block matchers" do
@@ -93,3 +93,4 @@ module Rspec
     end
   end
 end
+

data/spec/rspec/mocks/mock_ordering_spec.rb

@@ -3,90 +3,90 @@ require 'spec_helper'
 module Rspec
   module Mocks
 
-    describe "Mock ordering" do
+    describe "ordering" do
 
       before do
-        @mock = mock("test mock")
+        @double = double("test double")
       end
       
       after do
-        @mock.rspec_reset
+        @double.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
+        @double.should_receive(:one).ordered
+        @double.should_receive(:two).ordered
+        @double.one
+        @double.two
+        @double.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
+        @double.should_receive(:one).ordered
+        @double.should_receive(:two).ordered
+        @double.should_receive(:three).ordered
+        @double.one
+        @double.two
+        @double.three
+        @double.rspec_verify
       end
 
       it "should fail if second call comes first" do
-        @mock.should_receive(:one).ordered
-        @mock.should_receive(:two).ordered
+        @double.should_receive(:one).ordered
+        @double.should_receive(:two).ordered
         lambda do
-          @mock.two
-        end.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'test mock' received :two out of order")
+          @double.two
+        end.should raise_error(Rspec::Mocks::MockExpectationError, "Double \"test double\" 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
+        @double.should_receive(:one).ordered
+        @double.should_receive(:two).ordered
+        @double.should_receive(:three).ordered
+        @double.one
         lambda do
-          @mock.three
-        end.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'test mock' received :three out of order")
+          @double.three
+        end.should raise_error(Rspec::Mocks::MockExpectationError, "Double \"test double\" 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
+        @double.should_receive(:one).ordered
+        @double.should_receive(:two).ordered
+        @double.should_receive(:three).ordered
+        @double.one
         lambda do
-          @mock.three
-        end.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'test mock' received :three out of order")
+          @double.three
+        end.should raise_error(Rspec::Mocks::MockExpectationError, "Double \"test double\" 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
+        @double.should_receive(:ignored_0)
+        @double.should_receive(:ordered_1).ordered
+        @double.should_receive(:ignored_1)
+        @double.should_receive(:ordered_2).ordered
+        @double.should_receive(:ignored_2)
+        @double.should_receive(:ignored_3)
+        @double.should_receive(:ordered_3).ordered
+        @double.should_receive(:ignored_4)
+        @double.ignored_3
+        @double.ordered_1
+        @double.ignored_0
+        @double.ordered_2
+        @double.ignored_4
+        @double.ignored_2
+        @double.ordered_3
+        @double.ignored_1
+        @double.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
+        @double.should_receive(:a).ordered
+        @double.should_receive(:b).ordered
+        @double.should_receive(:a).ordered
         
-        @mock.a
-        @mock.b
-        @mock.a
+        @double.a
+        @double.b
+        @double.a
       end
             
     end

data/spec/rspec/mocks/mock_space_spec.rb

@@ -31,19 +31,19 @@ module Rspec
         @m2.should be_verified
       end
       it "should reset all mocks within" do
-        @space.add(m1 = mock("mock1"))
-        @space.add(m2 = mock("mock2"))
+        @space.add(m1 = double("mock1"))
+        @space.add(m2 = double("mock2"))
         m1.should_receive(:rspec_reset)
         m2.should_receive(:rspec_reset)
         @space.reset_all
       end
       it "should clear internal mocks on reset_all" do
-        @space.add(m = mock("mock"))
+        @space.add(m = double("mock"))
         @space.reset_all
         @space.instance_eval { mocks.empty? }.should be_true
       end
       it "should only add an instance once" do
-        @space.add(m1 = mock("mock1"))
+        @space.add(m1 = double("mock1"))
         @space.add(m1)
         m1.should_receive(:rspec_verify)
         @space.verify_all

data/spec/rspec/mocks/mock_spec.rb

@@ -6,7 +6,7 @@ module Rspec
       treats_method_missing_as_private :subject => Rspec::Mocks::Mock.new, :noop => false
       
       before(:each) do
-        @mock = mock("test mock")
+        @mock = double("test double")
       end
 
       after(:each) do
@@ -25,7 +25,7 @@ module Rspec
       end
 
       it "should report line number of expectation of unreceived message after #should_receive after similar stub" do
-        @mock.stub!(:wont_happen)
+        @mock.stub(:wont_happen)
         expected_error_line = __LINE__; @mock.should_receive(:wont_happen).with("x", 3)
         begin
           @mock.rspec_verify
@@ -50,18 +50,24 @@ module Rspec
 
       it "should fail when receiving message specified as not to be received" do
         @mock.should_not_receive(:not_expected)
-        lambda {
+        expect {
           @mock.not_expected
           violated
-        }.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'test mock' expected :not_expected with (no args) 0 times, but received it once")
+        }.to raise_error(
+          Rspec::Mocks::MockExpectationError, 
+          %Q|(Double "test double").not_expected(no args)\n    expected: 0 times\n    received: 1 time|
+        )
       end
 
       it "should fail when receiving message specified as not to be received with args" do
         @mock.should_not_receive(:not_expected).with("unexpected text")
-        lambda {
+        expect {
           @mock.not_expected("unexpected text")
           violated
-        }.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'test mock' expected :not_expected with (\"unexpected text\") 0 times, but received it once")
+        }.to raise_error(
+          Rspec::Mocks::MockExpectationError, 
+          %Q|(Double "test double").not_expected("unexpected text")\n    expected: 0 times\n    received: 1 time|
+        )
       end
 
       it "should pass when receiving message specified as not to be received with wrong args" do
@@ -93,32 +99,32 @@ module Rspec
         lambda {
           @mock.something("a","d","c")
           violated
-        }.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'test mock' expected :something with (\"a\", \"b\", \"c\") but received it with (\"a\", \"d\", \"c\")")
+        }.should raise_error(Rspec::Mocks::MockExpectationError, "Double \"test double\" received :something with unexpected arguments\n  expected: (\"a\", \"b\", \"c\")\n       got: (\"a\", \"d\", \"c\")")
       end
 
       it "should raise exception if args don't match when method called even when the method is stubbed" do
-        @mock.stub!(:something)
+        @mock.stub(:something)
         @mock.should_receive(:something).with("a","b","c")
         lambda {
           @mock.something("a","d","c")
           @mock.rspec_verify
-        }.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'test mock' expected :something with (\"a\", \"b\", \"c\") but received it with ([\"a\", \"d\", \"c\"])")
+        }.should raise_error(Rspec::Mocks::MockExpectationError, "Double \"test double\" received :something with unexpected arguments\n  expected: (\"a\", \"b\", \"c\")\n       got: (\"a\", \"d\", \"c\")")
       end
 
       it "should raise exception if args don't match when method called even when using null_object" do
-        @mock = mock("test mock", :null_object => true)
+        @mock = double("test double", :null_object => true)
         @mock.should_receive(:something).with("a","b","c")
         lambda {
           @mock.something("a","d","c")
           @mock.rspec_verify
-        }.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'test mock' expected :something with (\"a\", \"b\", \"c\") but received it with ([\"a\", \"d\", \"c\"])")
+        }.should raise_error(Rspec::Mocks::MockExpectationError, "Double \"test double\" received :something with unexpected arguments\n  expected: (\"a\", \"b\", \"c\")\n       got: (\"a\", \"d\", \"c\")")
       end
 
       it "should fail if unexpected method called" do
         lambda {
           @mock.something("a","b","c")
           violated
-        }.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'test mock' received unexpected message :something with (\"a\", \"b\", \"c\")")
+        }.should raise_error(Rspec::Mocks::MockExpectationError, "Double \"test double\" received unexpected message :something with (\"a\", \"b\", \"c\")")
       end
 
       it "should use block for expectation if provided" do
@@ -133,23 +139,25 @@ module Rspec
 
       it "should fail if expectation block fails" do
         @mock.should_receive(:something) {| bool | bool.should be_true}
-        lambda {
+        expect {
           @mock.something false
-        }.should raise_error(Rspec::Mocks::MockExpectationError, /Mock 'test mock' received :something but passed block failed with: expected false to be true/)
+        }.to raise_error(Rspec::Mocks::MockExpectationError, /Double \"test double\" received :something but passed block failed with: expected false to be true/)
       end
 
       it "should fail right away when method defined as never is received" do
         @mock.should_receive(:not_expected).never
-        lambda {
-          @mock.not_expected
-        }.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'test mock' expected :not_expected with (no args) 0 times, but received it once")
+        expect { @mock.not_expected }.to raise_error(
+          Rspec::Mocks::MockExpectationError, 
+          %Q|(Double "test double").not_expected(no args)\n    expected: 0 times\n    received: 1 time|
+        )
       end
 
       it "should eventually fail when method defined as never is received" do
         @mock.should_receive(:not_expected).never
-        lambda {
-          @mock.not_expected
-        }.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'test mock' expected :not_expected with (no args) 0 times, but received it once")
+        expect { @mock.not_expected }.to raise_error(
+          Rspec::Mocks::MockExpectationError, 
+          %Q|(Double "test double").not_expected(no args)\n    expected: 0 times\n    received: 1 time|
+        )
       end
 
       it "should raise when told to" do
@@ -209,18 +217,18 @@ module Rspec
         @mock.should_receive(:something).with(no_args())
         lambda {
           @mock.something 1
-        }.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'test mock' expected :something with (no args) but received it with (1)")
+        }.should raise_error(Rspec::Mocks::MockExpectationError, "Double \"test double\" received :something with unexpected arguments\n  expected: (no args)\n       got: (1)")
       end
 
       it "should fail when args are expected but none are received" do
         @mock.should_receive(:something).with(1)
         lambda {
           @mock.something
-        }.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'test mock' expected :something with (1) but received it with (no args)")
+        }.should raise_error(Rspec::Mocks::MockExpectationError, "Double \"test double\" received :something with unexpected arguments\n  expected: (1)\n       got: (no args)")
       end
 
       it "should return value from block by default" do
-        @mock.stub!(:method_that_yields).and_yield
+        @mock.stub(:method_that_yields).and_yield
         @mock.method_that_yields { :returned_obj }.should == :returned_obj
         @mock.rspec_verify
       end
@@ -324,7 +332,7 @@ module Rspec
         @mock.should_receive(:yield_back).with(no_args()).once.and_yield('wha', 'zup')
         lambda {
           @mock.yield_back {|a|}
-        }.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'test mock' yielded |\"wha\", \"zup\"| to block with arity of 1")
+        }.should raise_error(Rspec::Mocks::MockExpectationError, "Double \"test double\" yielded |\"wha\", \"zup\"| to block with arity of 1")
       end
 
       it "should fail when calling yielding method consecutively with wrong arity" do
@@ -335,14 +343,14 @@ module Rspec
           a, b = nil
           c = []
           @mock.yield_back {|a,b| c << [a, b]}
-        }.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'test mock' yielded |\"down\"| to block with arity of 2")
+        }.should raise_error(Rspec::Mocks::MockExpectationError, "Double \"test double\" yielded |\"down\"| to block with arity of 2")
       end
 
       it "should fail when calling yielding method without block" do
         @mock.should_receive(:yield_back).with(no_args()).once.and_yield('wha', 'zup')
         lambda {
           @mock.yield_back
-        }.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'test mock' asked to yield |[\"wha\", \"zup\"]| but no block was passed")
+        }.should raise_error(Rspec::Mocks::MockExpectationError, "Double \"test double\" asked to yield |[\"wha\", \"zup\"]| but no block was passed")
       end
 
       it "should be able to mock send" do
@@ -369,11 +377,11 @@ module Rspec
         @mock.rspec_verify
         lambda {
           @mock.foobar
-        }.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'test mock' received unexpected message :foobar with (no args)")
+        }.should raise_error(Rspec::Mocks::MockExpectationError, %q|Double "test double" received unexpected message :foobar with (no args)|)
       end
 
       it "should restore objects to their original state on rspec_reset" do
-        mock = mock("this is a mock")
+        mock = double("this is a mock")
         mock.should_receive(:blah)
         mock.rspec_reset
         mock.rspec_verify #should throw if reset didn't work
@@ -409,7 +417,7 @@ module Rspec
       end
 
       it "should temporarily replace a method stub on a mock" do
-        @mock.stub!(:msg).and_return(:stub_value)
+        @mock.stub(:msg).and_return(:stub_value)
         @mock.should_receive(:msg).with(:arg).and_return(:mock_value)
         @mock.msg(:arg).should equal(:mock_value)
         @mock.msg.should equal(:stub_value)
@@ -418,7 +426,7 @@ module Rspec
       end
 
       it "should not require a different signature to replace a method stub" do
-        @mock.stub!(:msg).and_return(:stub_value)
+        @mock.stub(:msg).and_return(:stub_value)
         @mock.should_receive(:msg).and_return(:mock_value)
         @mock.msg(:arg).should equal(:mock_value)
         @mock.msg.should equal(:stub_value)
@@ -427,14 +435,14 @@ module Rspec
       end
 
       it "should raise an error when a previously stubbed method has a negative expectation" do
-        @mock.stub!(:msg).and_return(:stub_value)
+        @mock.stub(:msg).and_return(:stub_value)
         @mock.should_not_receive(:msg).and_return(:mock_value)
         lambda {@mock.msg(:arg)}.should raise_error(Rspec::Mocks::MockExpectationError)
       end
 
       it "should temporarily replace a method stub on a non-mock" do
         non_mock = Object.new
-        non_mock.stub!(:msg).and_return(:stub_value)
+        non_mock.stub(:msg).and_return(:stub_value)
         non_mock.should_receive(:msg).with(:arg).and_return(:mock_value)
         non_mock.msg(:arg).should equal(:mock_value)
         non_mock.msg.should equal(:stub_value)
@@ -443,14 +451,14 @@ module Rspec
       end
 
       it "should return the stubbed value when no new value specified" do
-        @mock.stub!(:msg).and_return(:stub_value)
+        @mock.stub(:msg).and_return(:stub_value)
         @mock.should_receive(:msg)
         @mock.msg.should equal(:stub_value)
         @mock.rspec_verify
       end
 
       it "should not mess with the stub's yielded values when also mocked" do
-        @mock.stub!(:yield_back).and_yield(:stub_value)
+        @mock.stub(:yield_back).and_yield(:stub_value)
         @mock.should_receive(:yield_back).and_yield(:mock_value)
         @mock.yield_back{|v| v.should == :mock_value }
         @mock.yield_back{|v| v.should == :stub_value }
@@ -458,7 +466,7 @@ module Rspec
       end
 
       it "should yield multiple values after a similar stub" do
-        File.stub!(:open).and_yield(:stub_value)
+        File.stub(:open).and_yield(:stub_value)
         File.should_receive(:open).and_yield(:first_call).and_yield(:second_call)
         yielded_args = []
         File.open {|v| yielded_args << v }
@@ -476,7 +484,7 @@ module Rspec
 
     describe "a mock message receiving a block" do
       before(:each) do
-        @mock = mock("mock")
+        @mock = double("mock")
         @calls = 0
       end
 
@@ -493,7 +501,7 @@ module Rspec
       end
 
       it "should call the block after #should_receive after a similar stub" do
-        @mock.stub!(:foo).and_return(:bar)
+        @mock.stub(:foo).and_return(:bar)
         @mock.should_receive(:foo) { add_call }
 
         @mock.foo
@@ -547,33 +555,29 @@ module Rspec
 
     describe 'string representation generated by #to_s' do
       it 'should not contain < because that might lead to invalid HTML in some situations' do
-        mock = mock("Dog")
+        mock = double("Dog")
         valid_html_str = "#{mock}"
         valid_html_str.should_not include('<')
       end
     end
 
     describe "mock created with no name" do
-      it "should name itself 'mock'" do
-        mock.to_s.should include('mock')
-      end
-
-      it "should name itself after initially stubbed methods" do
-        string = mock(:foo => "woo", :bar => "car").to_s
-        string.should include('foo: \"woo\"', 'bar: \"car\"')
+      it "should not use a name in a failure message" do
+        mock = double()
+        expect {mock.foo}.to raise_error(/Double received/)
       end
-
+      
       it "should respond to initially stubbed methods" do
-        mock = mock(:foo => "woo", :bar => "car")
-        mock.foo.should == "woo"
-        mock.bar.should == "car"
+        double = double(:foo => "woo", :bar => "car")
+        double.foo.should == "woo"
+        double.bar.should == "car"
       end
     end
 
     describe "==" do
       it "sends '== self' to the comparison object" do
-        first = mock('first')
-        second = mock('second')
+        first = double('first')
+        second = double('second')
 
         first.should_receive(:==).with(second)
         second == first