rspec-mocks 2.0.0.beta.1 → 2.0.0.beta.2

data/VERSION

@@ -1 +1 @@
-2.0.0.beta.1
+2.0.0.beta.2

data/spec/rspec/mocks/any_number_of_times_spec.rb

@@ -5,7 +5,7 @@ module Rspec
     
     describe "AnyNumberOfTimes" do
       before(:each) do
-        @mock = Mock.new("test mock")
+        @mock = Rspec::Mocks::Mock.new("test mock")
       end
 
       it "should pass if any number of times method is called many times" do

data/spec/rspec/mocks/at_least_spec.rb

@@ -4,14 +4,14 @@ module Rspec
   module Mocks
     describe "at_least" do
       before(:each) do
-        @mock = Mock.new("test mock")
+        @mock = Rspec::Mocks::Mock.new("test mock")
       end
 
       it "should fail if method is never called" do
         @mock.should_receive(:random_call).at_least(4).times
           lambda do
         @mock.rspec_verify
-        end.should raise_error(MockExpectationError)
+        end.should raise_error(Rspec::Mocks::MockExpectationError)
       end
 
       it "should fail when called less than n times" do
@@ -21,14 +21,14 @@ module Rspec
         @mock.random_call
         lambda do
           @mock.rspec_verify
-        end.should raise_error(MockExpectationError)
+        end.should raise_error(Rspec::Mocks::MockExpectationError)
       end
 
       it "should fail when at least once method is never called" do
         @mock.should_receive(:random_call).at_least(:once)
         lambda do
           @mock.rspec_verify
-        end.should raise_error(MockExpectationError)
+        end.should raise_error(Rspec::Mocks::MockExpectationError)
       end
 
       it "should fail when at least twice method is called once" do
@@ -36,14 +36,14 @@ module Rspec
         @mock.random_call
         lambda do
           @mock.rspec_verify
-        end.should raise_error(MockExpectationError)
+        end.should raise_error(Rspec::Mocks::MockExpectationError)
       end
 
       it "should fail when at least twice method is never called" do
         @mock.should_receive(:random_call).at_least(:twice)
         lambda do
           @mock.rspec_verify
-        end.should raise_error(MockExpectationError)
+        end.should raise_error(Rspec::Mocks::MockExpectationError)
       end
 
       it "should pass when at least n times method is called exactly n times" do

data/spec/rspec/mocks/at_most_spec.rb

@@ -4,7 +4,7 @@ module Rspec
   module Mocks
     describe "at_most" do
       before(:each) do
-        @mock = Mock.new("test mock")
+        @mock = Rspec::Mocks::Mock.new("test mock")
       end
 
       it "should fail when at most n times method is called n plus 1 times" do
@@ -16,7 +16,7 @@ module Rspec
         @mock.random_call
         lambda do
           @mock.rspec_verify
-        end.should raise_error(MockExpectationError)
+        end.should raise_error(Rspec::Mocks::MockExpectationError)
       end
 
       it "should fail when at most once method is called twice" do
@@ -25,7 +25,7 @@ module Rspec
         @mock.random_call
         lambda do
           @mock.rspec_verify
-        end.should raise_error(MockExpectationError)
+        end.should raise_error(Rspec::Mocks::MockExpectationError)
       end
 
       it "should fail when at most twice method is called three times" do
@@ -35,7 +35,7 @@ module Rspec
         @mock.random_call
         lambda do
           @mock.rspec_verify
-        end.should raise_error(MockExpectationError)
+        end.should raise_error(Rspec::Mocks::MockExpectationError)
       end
 
       it "should pass when at most n times method is called exactly n times" do

data/spec/rspec/mocks/bug_report_496_spec.rb

@@ -1,15 +1,17 @@
 require 'spec_helper'
 
 module BugReport496
-  class BaseClass
-  end
+  describe "a message expectation on a base class object" do
+    class BaseClass
+    end
 
-  class SubClass < BaseClass
-  end
+    class SubClass < BaseClass
+    end
 
-  describe "a message expectation on a base class object" do
-    BaseClass.should_receive(:new).once
-    SubClass.new
+    it "is received" do
+      BaseClass.should_receive(:new).once
+      SubClass.new
+    end
   end
 end
 

data/spec/rspec/mocks/bug_report_600_spec.rb

@@ -1,15 +1,15 @@
 require 'spec_helper'
 
 module BugReport600
-  class ExampleClass
-    def self.method_that_uses_define_method
-      define_method "defined_method" do |attributes|
-        load_address(address, attributes)
+  describe "stubbing a class method" do
+    class ExampleClass
+      def self.method_that_uses_define_method
+        define_method "defined_method" do |attributes|
+          load_address(address, attributes)
+        end
       end
     end
-  end
  
-  describe "stubbing a class method" do
     it "should work" do
       ExampleClass.should_receive(:define_method).with("defined_method")
       ExampleClass.method_that_uses_define_method

data/spec/rspec/mocks/bug_report_7611_spec.rb

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

data/spec/rspec/mocks/bug_report_8302_spec.rb

@@ -1,15 +1,15 @@
 require 'spec_helper'
 
 module Bug8302
-  class Foo
-    def Foo.class_method(arg)
-    end
+  describe "Bug report 8302:" do
+    class Foo
+      def Foo.class_method(arg)
+      end
   
-    def instance_bar(arg)
+      def instance_bar(arg)
+      end
     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

data/spec/rspec/mocks/bug_report_830_spec.rb

@@ -14,7 +14,7 @@ module Rspec
         Foo.should_not_receive :bar
         lambda do
           Foo.foo
-        end.should raise_error(MockExpectationError)
+        end.should raise_error(Rspec::Mocks::MockExpectationError)
       end
     end
   end

data/spec/rspec/mocks/failing_argument_matchers_spec.rb

@@ -5,7 +5,7 @@ module Rspec
     describe "failing MockArgumentMatchers" do
       before(:each) do
         @mock = mock("test mock")
-        @reporter = Mock.new("reporter", :null_object => true)
+        @reporter = Rspec::Mocks::Mock.new("reporter", :null_object => true)
       end
       
       after(:each) do
@@ -16,71 +16,71 @@ module Rspec
         @mock.should_receive(:random_call).with(boolean())
         lambda do
           @mock.random_call("false")
-        end.should raise_error(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(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(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(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(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(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(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, /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
       
       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' 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, /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
       
       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' expected :msg with (equal 3) but received it with (37)")
+        end.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'test mock' expected :msg with (equal 3) but received it with (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' expected :msg with (no args) but received it with (37)")
+        end.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'test mock' expected :msg with (no args) but received it with (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' expected :msg with (hash_including(:a=>1)) but received it with ({})")
+         end.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'test mock' expected :msg with (hash_including(:a=>1)) but received it with ({})")
       end
 
       it "should fail with block matchers" do

data/spec/rspec/mocks/mock_ordering_spec.rb

@@ -36,7 +36,7 @@ module Rspec
         @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(Rspec::Mocks::MockExpectationError, "Mock 'test mock' received :two out of order")
       end
 
       it "should fail if third call comes first" do
@@ -46,7 +46,7 @@ module Rspec
         @mock.one
         lambda do
           @mock.three
-        end.should raise_error(MockExpectationError, "Mock 'test mock' received :three out of order")
+        end.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'test mock' received :three out of order")
       end
       
       it "should fail if third call comes second" do
@@ -56,7 +56,7 @@ module Rspec
         @mock.one
         lambda do
           @mock.three
-        end.should raise_error(MockExpectationError, "Mock 'test mock' received :three out of order")
+        end.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'test mock' received :three out of order")
       end
 
       it "should ignore order of non ordered calls" do

data/spec/rspec/mocks/mock_space_spec.rb

@@ -5,7 +5,7 @@ module Rspec
   module Mocks
     describe Space do
       before :each do
-        @space = Space.new
+        @space = Rspec::Mocks::Space.new
         klazz = Class.new do
           def rspec_verify
             @verified = true

data/spec/rspec/mocks/mock_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 module Rspec
   module Mocks
     describe Mock do
-      treats_method_missing_as_private :subject => Mock.new, :noop => false
+      treats_method_missing_as_private :subject => Rspec::Mocks::Mock.new, :noop => false
       
       before(:each) do
         @mock = mock("test mock")
@@ -18,7 +18,7 @@ module Rspec
         begin
           @mock.rspec_verify
           violated
-        rescue 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 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
@@ -53,7 +53,7 @@ module Rspec
         lambda {
           @mock.not_expected
           violated
-        }.should raise_error(MockExpectationError, "Mock 'test mock' expected :not_expected with (no args) 0 times, but received it once")
+        }.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'test mock' expected :not_expected with (no args) 0 times, but received it once")
       end
 
       it "should fail when receiving message specified as not to be received with args" do
@@ -61,7 +61,7 @@ module Rspec
         lambda {
           @mock.not_expected("unexpected text")
           violated
-        }.should raise_error(MockExpectationError, "Mock 'test mock' expected :not_expected with (\"unexpected text\") 0 times, but received it once")
+        }.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'test mock' expected :not_expected with (\"unexpected text\") 0 times, but received it once")
       end
 
       it "should pass when receiving message specified as not to be received with wrong args" do
@@ -93,7 +93,7 @@ module Rspec
         lambda {
           @mock.something("a","d","c")
           violated
-        }.should raise_error(MockExpectationError, "Mock 'test mock' expected :something with (\"a\", \"b\", \"c\") but received it with (\"a\", \"d\", \"c\")")
+        }.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'test mock' expected :something with (\"a\", \"b\", \"c\") but received it with (\"a\", \"d\", \"c\")")
       end
 
       it "should raise exception if args don't match when method called even when the method is stubbed" do
@@ -102,7 +102,7 @@ module Rspec
         lambda {
           @mock.something("a","d","c")
           @mock.rspec_verify
-        }.should raise_error(MockExpectationError, "Mock 'test mock' expected :something with (\"a\", \"b\", \"c\") but received it with ([\"a\", \"d\", \"c\"])")
+        }.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'test mock' expected :something with (\"a\", \"b\", \"c\") but received it with ([\"a\", \"d\", \"c\"])")
       end
 
       it "should raise exception if args don't match when method called even when using null_object" do
@@ -111,14 +111,14 @@ module Rspec
         lambda {
           @mock.something("a","d","c")
           @mock.rspec_verify
-        }.should raise_error(MockExpectationError, "Mock 'test mock' expected :something with (\"a\", \"b\", \"c\") but received it with ([\"a\", \"d\", \"c\"])")
+        }.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'test mock' expected :something with (\"a\", \"b\", \"c\") but received it with ([\"a\", \"d\", \"c\"])")
       end
 
       it "should fail if unexpected method called" do
         lambda {
           @mock.something("a","b","c")
           violated
-        }.should raise_error(MockExpectationError, "Mock 'test mock' received unexpected message :something with (\"a\", \"b\", \"c\")")
+        }.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'test mock' received unexpected message :something with (\"a\", \"b\", \"c\")")
       end
 
       it "should use block for expectation if provided" do
@@ -135,21 +135,21 @@ module Rspec
         @mock.should_receive(:something) {| bool | bool.should be_true}
         lambda {
           @mock.something false
-        }.should raise_error(MockExpectationError, /Mock 'test mock' received :something but passed block failed with: expected false to be true/)
+        }.should raise_error(Rspec::Mocks::MockExpectationError, /Mock 'test mock' 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(MockExpectationError, "Mock 'test mock' expected :not_expected with (no args) 0 times, but received it once")
+        }.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'test mock' expected :not_expected with (no args) 0 times, but received it once")
       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(MockExpectationError, "Mock 'test mock' expected :not_expected with (no args) 0 times, but received it once")
+        }.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'test mock' expected :not_expected with (no args) 0 times, but received it once")
       end
 
       it "should raise when told to" do
@@ -178,7 +178,7 @@ module Rspec
         @mock.should_receive(:something).with(2).and_raise(RuntimeError)
         lambda {
           @mock.something 1
-        }.should raise_error(MockExpectationError)
+        }.should raise_error(Rspec::Mocks::MockExpectationError)
       end
 
       it "should throw when told to" do
@@ -193,7 +193,7 @@ module Rspec
           @mock.should_receive(:fruit) do |colour|
             :strawberry
           end.and_return :apple
-        }.should raise_error(AmbiguousReturnError)
+        }.should raise_error(Rspec::Mocks::AmbiguousReturnError)
       end
 
       it "should ignore args on any args" do
@@ -209,14 +209,14 @@ module Rspec
         @mock.should_receive(:something).with(no_args())
         lambda {
           @mock.something 1
-        }.should raise_error(MockExpectationError, "Mock 'test mock' expected :something with (no args) but received it with (1)")
+        }.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'test mock' expected :something with (no args) but received it with (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(MockExpectationError, "Mock 'test mock' expected :something with (1) but received it with (no args)")
+        }.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'test mock' expected :something with (1) but received it with (no args)")
       end
 
       it "should return value from block by default" do
@@ -324,7 +324,7 @@ module Rspec
         @mock.should_receive(:yield_back).with(no_args()).once.and_yield('wha', 'zup')
         lambda {
           @mock.yield_back {|a|}
-        }.should raise_error(MockExpectationError, "Mock 'test mock' yielded |\"wha\", \"zup\"| to block with arity of 1")
+        }.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'test mock' yielded |\"wha\", \"zup\"| to block with arity of 1")
       end
 
       it "should fail when calling yielding method consecutively with wrong arity" do
@@ -335,14 +335,14 @@ module Rspec
           a, b = nil
           c = []
           @mock.yield_back {|a,b| c << [a, b]}
-        }.should raise_error(MockExpectationError, "Mock 'test mock' yielded |\"down\"| to block with arity of 2")
+        }.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'test mock' 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(MockExpectationError, "Mock 'test mock' asked to yield |[\"wha\", \"zup\"]| but no block was passed")
+        }.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'test mock' asked to yield |[\"wha\", \"zup\"]| but no block was passed")
       end
 
       it "should be able to mock send" do
@@ -369,7 +369,7 @@ module Rspec
         @mock.rspec_verify
         lambda {
           @mock.foobar
-        }.should raise_error(MockExpectationError, "Mock 'test mock' received unexpected message :foobar with (no args)")
+        }.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'test mock' received unexpected message :foobar with (no args)")
       end
 
       it "should restore objects to their original state on rspec_reset" do
@@ -405,7 +405,7 @@ module Rspec
         @mock.rspec_verify
 
         lambda { @mock.foobar }.should_not raise_error(NameError)
-        lambda { @mock.foobar }.should raise_error(MockExpectationError)
+        lambda { @mock.foobar }.should raise_error(Rspec::Mocks::MockExpectationError)
       end
 
       it "should temporarily replace a method stub on a mock" do
@@ -429,7 +429,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(MockExpectationError)
+        lambda {@mock.msg(:arg)}.should raise_error(Rspec::Mocks::MockExpectationError)
       end
 
       it "should temporarily replace a method stub on a non-mock" do
@@ -468,7 +468,7 @@ module Rspec
       end
 
       it "should assign stub return values" do
-        mock = Mock.new('name', :message => :response)
+        mock = Rspec::Mocks::Mock.new('name', :message => :response)
         mock.message.should == :response
       end
 

data/spec/rspec/mocks/multiple_return_value_spec.rb

@@ -4,7 +4,7 @@ module Rspec
   module Mocks
     describe "a Mock expectation with multiple return values and no specified count" do
       before(:each) do
-        @mock = 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
@@ -20,7 +20,7 @@ module Rspec
         third = Object.new
         @mock.message.should == @return_values[0]
         @mock.message.should == @return_values[1]
-        lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock 'mock' expected :message with (any args) 3 times, but received it twice")
+        lambda { @mock.rspec_verify }.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'mock' expected :message with (any args) 3 times, but received it twice")
       end
 
       it "should complain when there are too many calls" do
@@ -29,13 +29,13 @@ module Rspec
         @mock.message.should == @return_values[1]
         @mock.message.should == @return_values[2]
         @mock.message.should == @return_values[2]
-        lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock 'mock' expected :message with (any args) 3 times, but received it 4 times")
+        lambda { @mock.rspec_verify }.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'mock' expected :message with (any args) 3 times, but received it 4 times")
       end
     end
 
     describe "a Mock expectation with multiple return values with a specified count equal to the number of values" do
       before(:each) do
-        @mock = 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
@@ -51,7 +51,7 @@ module Rspec
         third = Object.new
         @mock.message.should == @return_values[0]
         @mock.message.should == @return_values[1]
-        lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock 'mock' expected :message with (any args) 3 times, but received it twice")
+        lambda { @mock.rspec_verify }.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'mock' expected :message with (any args) 3 times, but received it twice")
       end
 
       it "should complain when there are too many calls" do
@@ -60,13 +60,13 @@ module Rspec
         @mock.message.should == @return_values[1]
         @mock.message.should == @return_values[2]
         @mock.message.should == @return_values[2]
-        lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock 'mock' expected :message with (any args) 3 times, but received it 4 times")
+        lambda { @mock.rspec_verify }.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'mock' expected :message with (any args) 3 times, but received it 4 times")
       end
     end
 
     describe "a Mock expectation with multiple return values specifying at_least less than the number of values" do
       before(:each) do
-        @mock = Mock.new("mock")
+        @mock = Rspec::Mocks::Mock.new("mock")
         @mock.should_receive(:message).at_least(:twice).with(no_args).and_return(11, 22)
       end
       
@@ -79,12 +79,12 @@ module Rspec
 
       it "should fail when called less than the specified number" do
         @mock.message.should equal(11)
-        lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock 'mock' expected :message with (no args) twice, but received it once")
+        lambda { @mock.rspec_verify }.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'mock' expected :message with (no args) twice, but received it once")
       end
     end
     describe "a Mock expectation with multiple return values with a specified count larger than the number of values" do
       before(:each) do
-        @mock = Mock.new("mock")
+        @mock = Rspec::Mocks::Mock.new("mock")
         @mock.should_receive(:message).exactly(3).times.and_return(11, 22)
       end
       
@@ -97,7 +97,7 @@ module Rspec
 
       it "should fail when called less than the specified number" do
         @mock.message.should equal(11)
-        lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock 'mock' expected :message with (any args) 3 times, but received it once")
+        lambda { @mock.rspec_verify }.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'mock' expected :message with (any args) 3 times, but received it once")
       end
 
       it "should fail when called greater than the specified number" do
@@ -105,7 +105,7 @@ module Rspec
         @mock.message.should equal(22)
         @mock.message.should equal(22)
         @mock.message.should equal(22)
-        lambda { @mock.rspec_verify }.should raise_error(MockExpectationError, "Mock 'mock' expected :message with (any args) 3 times, but received it 4 times")
+        lambda { @mock.rspec_verify }.should raise_error(Rspec::Mocks::MockExpectationError, "Mock 'mock' expected :message with (any args) 3 times, but received it 4 times")
       end
     end
   end

data/spec/rspec/mocks/null_object_mock_spec.rb

@@ -4,7 +4,7 @@ module Rspec
   module Mocks
     describe "a mock acting as a NullObject" do
       before(:each) do
-        @mock = Mock.new("null_object", :null_object => true)
+        @mock = Rspec::Mocks::Mock.new("null_object", :null_object => true)
       end
 
       it "should allow explicit expectation" do
@@ -16,7 +16,7 @@ module Rspec
         lambda do
           @mock.should_receive(:something)
           @mock.rspec_verify
-        end.should raise_error(MockExpectationError)
+        end.should raise_error(Rspec::Mocks::MockExpectationError)
       end
 
       it "should ignore unexpected methods" do

data/spec/rspec/mocks/once_counts_spec.rb

@@ -11,7 +11,7 @@ module Rspec
         @mock.should_receive(:random_call).once.with("a", "b", "c")
         lambda do
           @mock.random_call("d", "e", "f")
-        end.should raise_error(MockExpectationError)
+        end.should raise_error(Rspec::Mocks::MockExpectationError)
         @mock.rspec_reset
       end
 
@@ -21,14 +21,14 @@ module Rspec
         @mock.random_call
         lambda do
           @mock.rspec_verify
-        end.should raise_error(MockExpectationError)
+        end.should raise_error(Rspec::Mocks::MockExpectationError)
       end
       
       it "once should fail when not called" do
         @mock.should_receive(:random_call).once
         lambda do
           @mock.rspec_verify
-        end.should raise_error(MockExpectationError)
+        end.should raise_error(Rspec::Mocks::MockExpectationError)
       end
 
       it "once should pass when called once" do

data/spec/rspec/mocks/partial_mock_spec.rb

@@ -31,11 +31,11 @@ module Rspec
         @object.should_not_receive(:fuhbar)
         lambda do
           @object.fuhbar
-        end.should raise_error(MockExpectationError, /<Object:.*> expected :fuhbar with \(no args\) 0 times/)
+        end.should raise_error(Rspec::Mocks::MockExpectationError, /<Object:.*> expected :fuhbar with \(no args\) 0 times/)
       end
     
       it "should_not_receive should return a negative message expectation" do
-        @object.should_not_receive(:foobar).should be_kind_of(NegativeMessageExpectation)
+        @object.should_not_receive(:foobar).should be_kind_of(Rspec::Mocks::NegativeMessageExpectation)
       end
     
       it "should_receive should mock out the method" do
@@ -55,7 +55,7 @@ module Rspec
       end
     
       it "should_receive should return a message expectation" do
-        @object.should_receive(:foobar).should be_kind_of(MessageExpectation)
+        @object.should_receive(:foobar).should be_kind_of(Rspec::Mocks::MessageExpectation)
         @object.foobar
       end
     

data/spec/rspec/mocks/partial_mock_using_mocks_directly_spec.rb

@@ -29,14 +29,14 @@ describe "PartialMockUsingMocksDirectly" do
         @obj.should_receive(:msg)
         lambda do
           @obj.rspec_verify
-        end.should raise_error(MockExpectationError)
+        end.should raise_error(Rspec::Mocks::MockExpectationError)
       
     end
     it "should fail when message is received with incorrect args" do
         @obj.should_receive(:msg).with(:correct_arg)
         lambda do
           @obj.msg(:incorrect_arg)
-        end.should raise_error(MockExpectationError)
+        end.should raise_error(Rspec::Mocks::MockExpectationError)
         @obj.msg(:correct_arg)
       
     end

data/spec/rspec/mocks/passing_argument_matchers_spec.rb

@@ -106,7 +106,7 @@ module Rspec
     describe Methods, "handling non-matcher arguments" do
       
       before(:each) do
-        @mock = Mock.new("test mock")
+        @mock = Rspec::Mocks::Mock.new("test mock")
       end
       
       it "should match non special symbol (can be removed when deprecated symbols are removed)" do

data/spec/rspec/mocks/precise_counts_spec.rb

@@ -13,14 +13,14 @@ module Rspec
         @mock.random_call
         lambda do
           @mock.rspec_verify
-        end.should raise_error(MockExpectationError)
+        end.should raise_error(Rspec::Mocks::MockExpectationError)
       end
 
       it "should fail when exactly n times method is never called" do
         @mock.should_receive(:random_call).exactly(3).times
         lambda do
           @mock.rspec_verify
-        end.should raise_error(MockExpectationError)
+        end.should raise_error(Rspec::Mocks::MockExpectationError)
       end
 
       it "should pass if exactly n times method is called exactly n times" do

data/spec/rspec/mocks/twice_counts_spec.rb

@@ -14,7 +14,7 @@ module Rspec
         @mock.random_call
         lambda do
           @mock.rspec_verify
-        end.should raise_error(MockExpectationError)
+        end.should raise_error(Rspec::Mocks::MockExpectationError)
       end
       
       it "twice should fail when call count is lower than expected" do
@@ -22,14 +22,14 @@ module Rspec
         @mock.random_call
         lambda do
           @mock.rspec_verify
-        end.should raise_error(MockExpectationError)
+        end.should raise_error(Rspec::Mocks::MockExpectationError)
       end
       
       it "twice should fail when called twice with wrong args on the first call" do
         @mock.should_receive(:random_call).twice.with("1", 1)
         lambda do
           @mock.random_call(1, "1")
-        end.should raise_error(MockExpectationError)
+        end.should raise_error(Rspec::Mocks::MockExpectationError)
         @mock.rspec_reset
       end
       
@@ -38,7 +38,7 @@ module Rspec
         @mock.random_call("1", 1)
         lambda do
           @mock.random_call(1, "1")
-        end.should raise_error(MockExpectationError)
+        end.should raise_error(Rspec::Mocks::MockExpectationError)
         @mock.rspec_reset
       end
       

metadata

@@ -7,8 +7,8 @@ version: !ruby/object:Gem::Version
   - 0
   - 0
   - beta
-  - 1
-  version: 2.0.0.beta.1
+  - 2
+  version: 2.0.0.beta.2
 platform: ruby
 authors: 
 - David Chelimsky
@@ -17,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-01 00:00:00 -06:00
+date: 2010-03-04 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -32,8 +32,8 @@ dependencies:
         - 0
         - 0
         - beta
-        - 1
-        version: 2.0.0.beta.1
+        - 2
+        version: 2.0.0.beta.2
   type: :development
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -48,8 +48,8 @@ dependencies:
         - 0
         - 0
         - beta
-        - 1
-        version: 2.0.0.beta.1
+        - 2
+        version: 2.0.0.beta.2
   type: :development
   version_requirements: *id002
 description: Rspec's 'test double' framework, with support for stubbing and mocking
@@ -136,7 +136,7 @@ licenses: []
 post_install_message: |
   **************************************************
   
-    Thank you for installing rspec-mocks-2.0.0.beta.1
+    Thank you for installing rspec-mocks-2.0.0.beta.2
   
     This is beta software. If you are looking
     for a supported production release, please
@@ -170,7 +170,7 @@ rubyforge_project: rspec
 rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
-summary: rspec-mocks-2.0.0.beta.1
+summary: rspec-mocks-2.0.0.beta.2
 test_files: 
 - spec/rspec/mocks/and_yield_spec.rb
 - spec/rspec/mocks/any_number_of_times_spec.rb