rspec-mocks 2.0.0.beta.8 → 2.0.0.beta.9

data/spec/rspec/mocks/bug_report_10260_spec.rb

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

data/spec/rspec/mocks/bug_report_15719_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-module Rspec
+module RSpec
   module Mocks
     describe "mock failure" do
       
@@ -9,7 +9,7 @@ module Rspec
         double.should_receive(:bar).with("message")
         lambda {
           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")})
+        }.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
 
@@ -21,7 +21,7 @@ module Rspec
         double.should_receive(:bar).with("message")
         lambda {
           double.bar("different message")
-        }.should raise_error(Rspec::Mocks::MockExpectationError, %Q{Double 'foo' expected :bar with ("message") but received it with ("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

data/spec/rspec/mocks/bug_report_830_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-module Rspec
+module RSpec
   module Mocks
     describe 'Calling a method that catches StandardError' do
       class Foo
@@ -14,7 +14,7 @@ module Rspec
         Foo.should_not_receive :bar
         lambda do
           Foo.foo
-        end.should raise_error(Rspec::Mocks::MockExpectationError)
+        end.should raise_error(RSpec::Mocks::MockExpectationError)
       end
     end
   end

data/spec/rspec/mocks/double_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe "double" do
   it "is an alias for stub and mock" do
-    double().should be_a(Rspec::Mocks::Mock)
+    double().should be_a(RSpec::Mocks::Mock)
   end
   
   it "uses 'Double' in failure messages" do

data/spec/rspec/mocks/failing_argument_matchers_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
-module Rspec
+module RSpec
   module Mocks
     describe "failing MockArgumentMatchers" do
       before(:each) do
         @mock = double("test double")
-        @reporter = Rspec::Mocks::Mock.new("reporter", :null_object => true)
+        @reporter = RSpec::Mocks::Mock.new("reporter").as_null_object
       end
       
       after(:each) do
@@ -16,78 +16,78 @@ module Rspec
         @mock.should_receive(:random_call).with(boolean())
         lambda do
           @mock.random_call("false")
-        end.should raise_error(Rspec::Mocks::MockExpectationError)
+        end.should raise_error(RSpec::Mocks::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(Rspec::Mocks::MockExpectationError)
+        end.should raise_error(RSpec::Mocks::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(Rspec::Mocks::MockExpectationError)
+        end.should raise_error(RSpec::Mocks::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(Rspec::Mocks::MockExpectationError)
+        lambda { @mock.random_call("I don't respond to :abs or :div") }.should raise_error(RSpec::Mocks::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(Rspec::Mocks::MockExpectationError)
+        lambda { @mock.random_call("abc") }.should raise_error(RSpec::Mocks::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(Rspec::Mocks::MockExpectationError)
+        lambda { @mock.random_call(/bcde/) }.should raise_error(RSpec::Mocks::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(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.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, /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.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, "Double \"test double\" received :msg with unexpected arguments\n  expected: (equal 3)\n       got: (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, "Double \"test double\" received :msg with unexpected arguments\n  expected: (no args)\n       got: (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, "Double \"test double\" received :msg with unexpected arguments\n  expected: (hash_including(:a=>1))\n       got: ({})")
+         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
         lambda do
           @mock.should_receive(:msg).with {|arg| arg.should == :received }
           @mock.msg :no_msg_for_you
-        end.should raise_error(Rspec::Expectations::ExpectationNotMetError, /expected: :received.*\s*.*got: :no_msg_for_you/)
+        end.should raise_error(RSpec::Expectations::ExpectationNotMetError, /expected: :received.*\s*.*got: :no_msg_for_you/)
       end
             
     end

data/spec/rspec/mocks/hash_including_matcher_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-module Rspec
+module RSpec
   module Mocks
     module ArgumentMatchers
       describe HashIncludingMatcher do

data/spec/rspec/mocks/hash_not_including_matcher_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-module Rspec
+module RSpec
   module Mocks
     module ArgumentMatchers
       describe HashNotIncludingMatcher do

data/spec/rspec/mocks/mock_ordering_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-module Rspec
+module RSpec
   module Mocks
 
     describe "ordering" do
@@ -36,7 +36,7 @@ module Rspec
         @double.should_receive(:two).ordered
         lambda do
           @double.two
-        end.should raise_error(Rspec::Mocks::MockExpectationError, "Double \"test double\" received :two out of order")
+        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
@@ -46,7 +46,7 @@ module Rspec
         @double.one
         lambda do
           @double.three
-        end.should raise_error(Rspec::Mocks::MockExpectationError, "Double \"test double\" received :three out of order")
+        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
@@ -56,7 +56,7 @@ module Rspec
         @double.one
         lambda do
           @double.three
-        end.should raise_error(Rspec::Mocks::MockExpectationError, "Double \"test double\" received :three out of order")
+        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

data/spec/rspec/mocks/mock_space_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 require 'rspec/mocks'
 
-module Rspec
+module RSpec
   module Mocks
     describe Space do
       before :each do
-        @space = Rspec::Mocks::Space.new
+        @space = RSpec::Mocks::Space.new
         klazz = Class.new do
           def rspec_verify
             @verified = true

data/spec/rspec/mocks/mock_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
-module Rspec
+module RSpec
   module Mocks
     describe Mock do
-      treats_method_missing_as_private :subject => Rspec::Mocks::Mock.new, :noop => false
+      treats_method_missing_as_private :subject => RSpec::Mocks::Mock.new, :noop => false
       
       before(:each) do
         @mock = double("test double")
@@ -18,7 +18,7 @@ module Rspec
         begin
           @mock.rspec_verify
           violated
-        rescue Rspec::Mocks::MockExpectationError => e
+        rescue RSpec::Mocks::MockExpectationError => e
           # NOTE - this regexp ended w/ $, but jruby adds extra info at the end of the line
           e.backtrace[0].should match(/#{File.basename(__FILE__)}:#{expected_error_line}/)
         end
@@ -30,7 +30,7 @@ module Rspec
         begin
           @mock.rspec_verify
           violated
-        rescue Rspec::Mocks::MockExpectationError => e
+        rescue RSpec::Mocks::MockExpectationError => e
           # NOTE - this regexp ended w/ $, but jruby adds extra info at the end of the line
           e.backtrace[0].should match(/#{File.basename(__FILE__)}:#{expected_error_line}/)
         end
@@ -54,7 +54,7 @@ module Rspec
           @mock.not_expected
           violated
         }.to raise_error(
-          Rspec::Mocks::MockExpectationError, 
+          RSpec::Mocks::MockExpectationError, 
           %Q|(Double "test double").not_expected(no args)\n    expected: 0 times\n    received: 1 time|
         )
       end
@@ -65,7 +65,7 @@ module Rspec
           @mock.not_expected("unexpected text")
           violated
         }.to raise_error(
-          Rspec::Mocks::MockExpectationError, 
+          RSpec::Mocks::MockExpectationError, 
           %Q|(Double "test double").not_expected("unexpected text")\n    expected: 0 times\n    received: 1 time|
         )
       end
@@ -99,7 +99,7 @@ module Rspec
         lambda {
           @mock.something("a","d","c")
           violated
-        }.should raise_error(Rspec::Mocks::MockExpectationError, "Double \"test double\" received :something with unexpected arguments\n  expected: (\"a\", \"b\", \"c\")\n       got: (\"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
@@ -108,23 +108,23 @@ module Rspec
         lambda {
           @mock.something("a","d","c")
           @mock.rspec_verify
-        }.should raise_error(Rspec::Mocks::MockExpectationError, "Double \"test double\" received :something with unexpected arguments\n  expected: (\"a\", \"b\", \"c\")\n       got: (\"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 = double("test double", :null_object => true)
+        @mock = double("test double").as_null_object
         @mock.should_receive(:something).with("a","b","c")
         lambda {
           @mock.something("a","d","c")
           @mock.rspec_verify
-        }.should raise_error(Rspec::Mocks::MockExpectationError, "Double \"test double\" received :something with unexpected arguments\n  expected: (\"a\", \"b\", \"c\")\n       got: (\"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, "Double \"test double\" 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
@@ -141,13 +141,13 @@ module Rspec
         @mock.should_receive(:something) {| bool | bool.should be_true}
         expect {
           @mock.something false
-        }.to raise_error(Rspec::Mocks::MockExpectationError, /Double \"test double\" 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
         expect { @mock.not_expected }.to raise_error(
-          Rspec::Mocks::MockExpectationError, 
+          RSpec::Mocks::MockExpectationError, 
           %Q|(Double "test double").not_expected(no args)\n    expected: 0 times\n    received: 1 time|
         )
       end
@@ -155,7 +155,7 @@ module Rspec
       it "should eventually fail when method defined as never is received" do
         @mock.should_receive(:not_expected).never
         expect { @mock.not_expected }.to raise_error(
-          Rspec::Mocks::MockExpectationError, 
+          RSpec::Mocks::MockExpectationError, 
           %Q|(Double "test double").not_expected(no args)\n    expected: 0 times\n    received: 1 time|
         )
       end
@@ -186,7 +186,7 @@ module Rspec
         @mock.should_receive(:something).with(2).and_raise(RuntimeError)
         lambda {
           @mock.something 1
-        }.should raise_error(Rspec::Mocks::MockExpectationError)
+        }.should raise_error(RSpec::Mocks::MockExpectationError)
       end
 
       it "should throw when told to" do
@@ -201,7 +201,7 @@ module Rspec
           @mock.should_receive(:fruit) do |colour|
             :strawberry
           end.and_return :apple
-        }.should raise_error(Rspec::Mocks::AmbiguousReturnError)
+        }.should raise_error(RSpec::Mocks::AmbiguousReturnError)
       end
 
       it "should ignore args on any args" do
@@ -217,14 +217,14 @@ module Rspec
         @mock.should_receive(:something).with(no_args())
         lambda {
           @mock.something 1
-        }.should raise_error(Rspec::Mocks::MockExpectationError, "Double \"test double\" received :something with unexpected arguments\n  expected: (no args)\n       got: (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, "Double \"test double\" received :something with unexpected arguments\n  expected: (1)\n       got: (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
@@ -332,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, "Double \"test double\" 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
@@ -343,14 +343,14 @@ module Rspec
           a, b = nil
           c = []
           @mock.yield_back {|a,b| c << [a, b]}
-        }.should raise_error(Rspec::Mocks::MockExpectationError, "Double \"test double\" 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, "Double \"test double\" 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
@@ -377,7 +377,7 @@ module Rspec
         @mock.rspec_verify
         lambda {
           @mock.foobar
-        }.should raise_error(Rspec::Mocks::MockExpectationError, %q|Double "test double" 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
@@ -413,7 +413,7 @@ module Rspec
         @mock.rspec_verify
 
         lambda { @mock.foobar }.should_not raise_error(NameError)
-        lambda { @mock.foobar }.should raise_error(Rspec::Mocks::MockExpectationError)
+        lambda { @mock.foobar }.should raise_error(RSpec::Mocks::MockExpectationError)
       end
 
       it "should temporarily replace a method stub on a mock" do
@@ -437,7 +437,7 @@ module Rspec
       it "should raise an error when a previously stubbed method has a negative expectation" do
         @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)
+        lambda {@mock.msg(:arg)}.should raise_error(RSpec::Mocks::MockExpectationError)
       end
 
       it "should temporarily replace a method stub on a non-mock" do
@@ -476,7 +476,7 @@ module Rspec
       end
 
       it "should assign stub return values" do
-        mock = Rspec::Mocks::Mock.new('name', :message => :response)
+        mock = RSpec::Mocks::Mock.new('name', :message => :response)
         mock.message.should == :response
       end
 
@@ -561,6 +561,13 @@ module Rspec
       end
     end
 
+    describe "string representation generated by #to_str" do
+      it "looks the same as #to_s" do
+        double = double("Foo")
+        double.to_str.should == double.to_s
+      end
+    end
+
     describe "mock created with no name" do
       it "should not use a name in a failure message" do
         mock = double()

data/spec/rspec/mocks/multiple_return_value_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
-module Rspec
+module RSpec
   module Mocks
     describe "a Mock expectation with multiple return values and no specified count" do
       before(:each) do
-        @mock = Rspec::Mocks::Mock.new("mock")
+        @mock = RSpec::Mocks::Mock.new("mock")
         @return_values = ["1",2,Object.new]
         @mock.should_receive(:message).and_return(@return_values[0],@return_values[1],@return_values[2])
       end
@@ -21,7 +21,7 @@ module Rspec
         @mock.message.should == @return_values[0]
         @mock.message.should == @return_values[1]
         expect { @mock.rspec_verify }.to raise_error(
-          Rspec::Mocks::MockExpectationError, 
+          RSpec::Mocks::MockExpectationError, 
           %Q|(Mock "mock").message(any args)\n    expected: 3 times\n    received: 2 times|
         )
       end
@@ -33,7 +33,7 @@ module Rspec
         @mock.message.should == @return_values[2]
         @mock.message.should == @return_values[2]
         expect { @mock.rspec_verify }.to raise_error(
-          Rspec::Mocks::MockExpectationError, 
+          RSpec::Mocks::MockExpectationError, 
           %Q|(Mock "mock").message(any args)\n    expected: 3 times\n    received: 4 times|
         )
       end
@@ -41,7 +41,7 @@ module Rspec
 
     describe "a Mock expectation with multiple return values with a specified count equal to the number of values" do
       before(:each) do
-        @mock = Rspec::Mocks::Mock.new("mock")
+        @mock = RSpec::Mocks::Mock.new("mock")
         @return_values = ["1",2,Object.new]
         @mock.should_receive(:message).exactly(3).times.and_return(@return_values[0],@return_values[1],@return_values[2])
       end
@@ -58,7 +58,7 @@ module Rspec
         @mock.message.should == @return_values[0]
         @mock.message.should == @return_values[1]
         expect { @mock.rspec_verify }.to raise_error(
-          Rspec::Mocks::MockExpectationError, 
+          RSpec::Mocks::MockExpectationError, 
           %Q|(Mock "mock").message(any args)\n    expected: 3 times\n    received: 2 times|
         )
       end
@@ -70,7 +70,7 @@ module Rspec
         @mock.message.should == @return_values[2]
         @mock.message.should == @return_values[2]
         expect { @mock.rspec_verify }.to raise_error(
-          Rspec::Mocks::MockExpectationError, 
+          RSpec::Mocks::MockExpectationError, 
           %Q|(Mock "mock").message(any args)\n    expected: 3 times\n    received: 4 times|
         )
       end
@@ -78,7 +78,7 @@ module Rspec
 
     describe "a Mock expectation with multiple return values specifying at_least less than the number of values" do
       before(:each) do
-        @mock = Rspec::Mocks::Mock.new("mock")
+        @mock = RSpec::Mocks::Mock.new("mock")
         @mock.should_receive(:message).at_least(:twice).with(no_args).and_return(11, 22)
       end
       
@@ -92,7 +92,7 @@ module Rspec
       it "should fail when called less than the specified number" do
         @mock.message.should equal(11)
         expect { @mock.rspec_verify }.to raise_error(
-          Rspec::Mocks::MockExpectationError, 
+          RSpec::Mocks::MockExpectationError, 
           %Q|(Mock "mock").message(no args)\n    expected: 2 times\n    received: 1 time|
         )
       end
@@ -100,7 +100,7 @@ module Rspec
 
     describe "a Mock expectation with multiple return values with a specified count larger than the number of values" do
       before(:each) do
-        @mock = Rspec::Mocks::Mock.new("mock")
+        @mock = RSpec::Mocks::Mock.new("mock")
         @mock.should_receive(:message).exactly(3).times.and_return(11, 22)
       end
       
@@ -114,7 +114,7 @@ module Rspec
       it "should fail when called less than the specified number" do
         @mock.message.should equal(11)
         expect { @mock.rspec_verify }.to raise_error(
-          Rspec::Mocks::MockExpectationError, 
+          RSpec::Mocks::MockExpectationError, 
           %Q|(Mock "mock").message(any args)\n    expected: 3 times\n    received: 1 time|
         )
       end
@@ -125,7 +125,7 @@ module Rspec
         @mock.message.should equal(22)
         @mock.message.should equal(22)
         expect { @mock.rspec_verify }.to raise_error(
-          Rspec::Mocks::MockExpectationError, 
+          RSpec::Mocks::MockExpectationError, 
           %Q|(Mock "mock").message(any args)\n    expected: 3 times\n    received: 4 times|
         )
       end