rspec-mocks 2.0.0.beta.19 → 2.0.0.beta.20

data/spec/rspec/mocks/multiple_return_value_spec.rb

@@ -9,14 +9,14 @@ module RSpec
         @mock.should_receive(:message).and_return(@return_values[0],@return_values[1],@return_values[2])
       end
       
-      it "should return values in order to consecutive calls" do
+      it "returns values in order to consecutive calls" do
         @mock.message.should == @return_values[0]
         @mock.message.should == @return_values[1]
         @mock.message.should == @return_values[2]
         @mock.rspec_verify
       end
 
-      it "should complain when there are too few calls" do
+      it "complains when there are too few calls" do
         @mock.message.should == @return_values[0]
         @mock.message.should == @return_values[1]
         expect { @mock.rspec_verify }.to raise_error(
@@ -25,7 +25,7 @@ module RSpec
         )
       end
 
-      it "should complain when there are too many calls" do
+      it "complains when there are too many calls" do
         @mock.message.should == @return_values[0]
         @mock.message.should == @return_values[1]
         @mock.message.should == @return_values[2]
@@ -44,14 +44,14 @@ module RSpec
         @mock.should_receive(:message).exactly(3).times.and_return(@return_values[0],@return_values[1],@return_values[2])
       end
 
-      it "should return values in order to consecutive calls" do
+      it "returns values in order to consecutive calls" do
         @mock.message.should == @return_values[0]
         @mock.message.should == @return_values[1]
         @mock.message.should == @return_values[2]
         @mock.rspec_verify
       end
 
-      it "should complain when there are too few calls" do
+      it "complains when there are too few calls" do
         third = Object.new
         @mock.message.should == @return_values[0]
         @mock.message.should == @return_values[1]
@@ -61,7 +61,7 @@ module RSpec
         )
       end
 
-      it "should complain when there are too many calls" do
+      it "complains when there are too many calls" do
         third = Object.new
         @mock.message.should == @return_values[0]
         @mock.message.should == @return_values[1]
@@ -80,14 +80,14 @@ module RSpec
         @mock.should_receive(:message).at_least(:twice).with(no_args).and_return(11, 22)
       end
       
-      it "should use last return value for subsequent calls" do
+      it "uses the last return value for subsequent calls" do
         @mock.message.should equal(11)
         @mock.message.should equal(22)
         @mock.message.should equal(22)
         @mock.rspec_verify
       end
 
-      it "should fail when called less than the specified number" do
+      it "fails when called less than the specified number" do
         @mock.message.should equal(11)
         expect { @mock.rspec_verify }.to raise_error(
           RSpec::Mocks::MockExpectationError, 
@@ -102,14 +102,14 @@ module RSpec
         @mock.should_receive(:message).exactly(3).times.and_return(11, 22)
       end
       
-      it "should use last return value for subsequent calls" do
+      it "uses the last return value for subsequent calls" do
         @mock.message.should equal(11)
         @mock.message.should equal(22)
         @mock.message.should equal(22)
         @mock.rspec_verify
       end
 
-      it "should fail when called less than the specified number" do
+      it "fails when called less than the specified number" do
         @mock.message.should equal(11)
         expect { @mock.rspec_verify }.to raise_error(
           RSpec::Mocks::MockExpectationError, 
@@ -117,7 +117,7 @@ module RSpec
         )
       end
 
-      it "should fail when called greater than the specified number" do
+      it "fails when called greater than the specified number" do
         @mock.message.should equal(11)
         @mock.message.should equal(22)
         @mock.message.should equal(22)

data/spec/rspec/mocks/nil_expectation_warning_spec.rb

@@ -14,7 +14,7 @@ module RSpec
 
     describe "an expectation set on nil" do
       
-      it "should issue a warning with file and line number information" do
+      it "issues a warning with file and line number information" do
         expected_warning = %r%An expectation of :foo was set on nil. Called from #{__FILE__}:#{__LINE__+3}(:in `block \(2 levels\) in <module:Mocks>')?. Use allow_message_expectations_on_nil to disable warnings.%
         Kernel.should_receive(:warn).with(expected_warning)
 
@@ -22,13 +22,13 @@ module RSpec
         nil.foo
       end
       
-      it "should issue a warning when the expectation is negative" do
+      it "issues a warning when the expectation is negative" do
         Kernel.should_receive(:warn)
 
         nil.should_not_receive(:foo)
       end
       
-      it "should not issue a warning when expectations are set to be allowed" do
+      it "does not issue a warning when expectations are set to be allowed" do
         allow_message_expectations_on_nil
         Kernel.should_not_receive(:warn)
         
@@ -42,7 +42,7 @@ module RSpec
     describe "#allow_message_expectations_on_nil" do
       
 
-      it "should not effect subsequent examples" do
+      it "does not effect subsequent examples" do
         example_group = empty_example_group
         example_group.it("when called in one example that doesn't end up setting an expectation on nil") do
                         allow_message_expectations_on_nil

data/spec/rspec/mocks/null_object_mock_spec.rb

@@ -7,30 +7,30 @@ module RSpec
         @mock = RSpec::Mocks::Mock.new("null_object").as_null_object
       end
 
-      it "should allow explicit expectation" do
+      it "allows explicit expectation" do
         @mock.should_receive(:something)
         @mock.something
       end
 
-      it "should fail verification when explicit exception not met" do
+      it "fails verification when explicit exception not met" do
         lambda do
           @mock.should_receive(:something)
           @mock.rspec_verify
         end.should raise_error(RSpec::Mocks::MockExpectationError)
       end
 
-      it "should ignore unexpected methods" do
+      it "ignores unexpected methods" do
         @mock.random_call("a", "d", "c")
         @mock.rspec_verify
       end
 
-      it "should expected message with different args first" do
+      it "allows expected message with different args first" do
         @mock.should_receive(:message).with(:expected_arg)
         @mock.message(:unexpected_arg)
         @mock.message(:expected_arg)
       end
 
-      it "should expected message with different args second" do
+      it "allows expected message with different args second" do
         @mock.should_receive(:message).with(:expected_arg)
         @mock.message(:expected_arg)
         @mock.message(:unexpected_arg)
@@ -38,14 +38,14 @@ module RSpec
     end
 
     describe "#null_object?" do
-      it "should default to false" do
+      it "defaults to false" do
         obj = double('anything')
         obj.should_not be_null_object
       end
     end
     
     describe "#as_null_object" do
-      it "should set the object to null_object" do
+      it "sets the object to null_object" do
         obj = double('anything').as_null_object
         obj.should be_null_object
       end

data/spec/rspec/mocks/once_counts_spec.rb

@@ -7,7 +7,7 @@ module RSpec
         @mock = double("test mock")
       end
 
-      it "once should fail when called once with wrong args" do
+      it "once fails when called once with wrong args" do
         @mock.should_receive(:random_call).once.with("a", "b", "c")
         lambda do
           @mock.random_call("d", "e", "f")
@@ -15,7 +15,7 @@ module RSpec
         @mock.rspec_reset
       end
 
-      it "once should fail when called twice" do
+      it "once fails when called twice" do
         @mock.should_receive(:random_call).once
         @mock.random_call
         @mock.random_call
@@ -24,26 +24,26 @@ module RSpec
         end.should raise_error(RSpec::Mocks::MockExpectationError)
       end
       
-      it "once should fail when not called" do
+      it "once fails when not called" do
         @mock.should_receive(:random_call).once
         lambda do
           @mock.rspec_verify
         end.should raise_error(RSpec::Mocks::MockExpectationError)
       end
 
-      it "once should pass when called once" do
+      it "once passes when called once" do
         @mock.should_receive(:random_call).once
         @mock.random_call
         @mock.rspec_verify
       end
 
-      it "once should pass when called once with specified args" do
+      it "once passes when called once with specified args" do
         @mock.should_receive(:random_call).once.with("a", "b", "c")
         @mock.random_call("a", "b", "c")
         @mock.rspec_verify
       end
 
-      it "once should pass when called once with unspecified args" do
+      it "once passes when called once with unspecified args" do
         @mock.should_receive(:random_call).once
         @mock.random_call("a", "b", "c")
         @mock.rspec_verify

data/spec/rspec/mocks/options_hash_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 module RSpec
   module Mocks
     describe "calling :should_receive with an options hash" do
-      it "should report the file and line submitted with :expected_from" do
+      it "reports the file and line submitted with :expected_from" do
         begin
           mock = RSpec::Mocks::Mock.new("a mock")
           mock.should_receive(:message, :expected_from => "/path/to/blah.ext:37")
@@ -14,7 +14,7 @@ module RSpec
         end
       end
 
-      it "should use the message supplied with :message" do
+      it "uses the message supplied with :message" do
         lambda {
           m = RSpec::Mocks::Mock.new("a mock")
           m.should_receive(:message, :message => "recebi nada")
@@ -22,7 +22,7 @@ module RSpec
         }.should raise_error("recebi nada")
       end
       
-      it "should use the message supplied with :message after a similar stub" do
+      it "uses the message supplied with :message after a similar stub" do
         lambda {
           m = RSpec::Mocks::Mock.new("a mock")
           m.stub(:message)

data/spec/rspec/mocks/partial_mock_spec.rb

@@ -7,27 +7,27 @@ module RSpec
         @object = Object.new
       end
     
-      it "should name the class in the failure message" do
+      it "names the class in the failure message" do
         @object.should_receive(:foo)
         expect do
           @object.rspec_verify
         end.to raise_error(RSpec::Mocks::MockExpectationError, /\(#<Object:.*>\).foo/)
       end
     
-      it "should name the class in the failure message when expectation is on class" do
+      it "names the class in the failure message when expectation is on class" do
         Object.should_receive(:foo)
         lambda do
           Object.rspec_verify
         end.should raise_error(RSpec::Mocks::MockExpectationError, /<Object \(class\)>/)
       end
     
-      it "should not conflict with @options in the object" do
+      it "does not conflict with @options in the object" do
         @object.instance_eval { @options = Object.new }
         @object.should_receive(:blah)
         @object.blah
       end
             
-      it "should_not_receive should mock out the method" do
+      it "should_not_receive mocks out the method" do
         @object.should_not_receive(:fuhbar)
         expect {
           @object.fuhbar
@@ -37,51 +37,51 @@ module RSpec
         )
       end
     
-      it "should_not_receive should return a negative message expectation" do
+      it "should_not_receive returns a negative message expectation" do
         @object.should_not_receive(:foobar).should be_kind_of(RSpec::Mocks::NegativeMessageExpectation)
       end
     
-      it "should_receive should mock out the method" do
+      it "should_receive mocks out the method" do
         @object.should_receive(:foobar).with(:test_param).and_return(1)
         @object.foobar(:test_param).should equal(1)
       end
     
-      it "should_receive should handle a hash" do
+      it "should_receive handles a hash" do
         @object.should_receive(:foobar).with(:key => "value").and_return(1)
         @object.foobar(:key => "value").should equal(1)
       end
     
-      it "should_receive should handle an inner hash" do
+      it "should_receive handles an inner hash" do
         hash = {:a => {:key => "value"}}
         @object.should_receive(:foobar).with(:key => "value").and_return(1)
         @object.foobar(hash[:a]).should equal(1)
       end
     
-      it "should_receive should return a message expectation" do
+      it "should_receive returns a message expectation" do
         @object.should_receive(:foobar).should be_kind_of(RSpec::Mocks::MessageExpectation)
         @object.foobar
       end
     
-      it "should_receive should verify method was called" do
+      it "should_receive verifies method was called" do
         @object.should_receive(:foobar).with(:test_param).and_return(1)
         lambda do
           @object.rspec_verify
         end.should raise_error(RSpec::Mocks::MockExpectationError)
       end
     
-      it "should_receive should also take a String argument" do
+      it "should_receive also takes a String argument" do
         @object.should_receive('foobar')
         @object.foobar
       end
       
-      it "should_not_receive should also take a String argument" do
+      it "should_not_receive also takes a String argument" do
         @object.should_not_receive('foobar')
         lambda do
           @object.foobar   
         end.should raise_error(RSpec::Mocks::MockExpectationError)
       end
       
-      it "should use report nil in the error message" do
+      it "uses reports nil in the error message" do
         allow_message_expectations_on_nil
         
         @this_will_resolve_to_nil.should_receive(:foobar)
@@ -110,7 +110,7 @@ module RSpec
         end
       end
       
-      it "should not raise an error when stubbing the object" do
+      it "does not raise an error when stubbing the object" do
         o = PartiallyMockedEquals.new :foo
         lambda { o.stub(:bar) }.should_not raise_error(NoMethodError)
       end
@@ -132,7 +132,7 @@ module RSpec
         @object = MockableClass.new
       end
 
-      it 'should keep public methods public' do
+      it 'keeps public methods public' do
         @object.should_receive(:public_method)
         with_ruby('1.9') do
           @object.public_methods.should include(:public_method)
@@ -143,7 +143,7 @@ module RSpec
         @object.public_method
       end
 
-      it 'should keep private methods private' do
+      it 'keeps private methods private' do
         @object.should_receive(:private_method)
         with_ruby('1.9') do
           @object.private_methods.should include(:private_method)
@@ -154,7 +154,7 @@ module RSpec
         @object.public_method
       end
 
-      it 'should keep protected methods protected' do
+      it 'keeps protected methods protected' do
         @object.should_receive(:protected_method)
         with_ruby('1.9') do
           @object.protected_methods.should include(:protected_method)

data/spec/rspec/mocks/partial_mock_using_mocks_directly_spec.rb

@@ -63,7 +63,7 @@ module RSpec::Mocks
       obj.rspec_verify
     end
 
-    it "should restore original method if existed" do
+    it "restores the original method if it existed" do
       obj.existing_method.should equal(:original_value)
       obj.should_receive(:existing_method).and_return(:mock_value)
       obj.existing_method.should equal(:mock_value)

data/spec/rspec/mocks/passing_argument_matchers_spec.rb

@@ -16,22 +16,22 @@ module RSpec
     describe Methods, "handling argument matchers" do
       include_mock_argument_matchers
 
-      it "should accept true as boolean()" do
+      it "accepts true as boolean()" do
         @mock.should_receive(:random_call).with(boolean())
         @mock.random_call(true)
       end
 
-      it "should accept false as boolean()" do
+      it "accepts false as boolean()" do
         @mock.should_receive(:random_call).with(boolean())
         @mock.random_call(false)
       end
 
-      it "should accept fixnum as kind_of(Numeric)" do
+      it "accepts fixnum as kind_of(Numeric)" do
         @mock.should_receive(:random_call).with(kind_of(Numeric))
         @mock.random_call(1)
       end
 
-      it "should accept float as an_instance_of(Numeric)" do
+      it "accepts float as an_instance_of(Numeric)" do
         @mock.should_receive(:random_call).with(kind_of(Numeric))
         @mock.random_call(1.5)
       end
@@ -41,47 +41,47 @@ module RSpec
         @mock.random_call(1)
       end
 
-      it "should NOT accept fixnum as instance_of(Numeric)" do
+      it "does NOT accept fixnum as instance_of(Numeric)" do
         @mock.should_not_receive(:random_call).with(instance_of(Numeric))
         @mock.random_call(1)
       end
 
-      it "should NOT accept float as instance_of(Numeric)" do
+      it "does NOT accept float as instance_of(Numeric)" do
         @mock.should_not_receive(:random_call).with(instance_of(Numeric))
         @mock.random_call(1.5)
       end
 
-      it "should accept string as anything()" do
+      it "accepts string as anything()" do
         @mock.should_receive(:random_call).with("a", anything(), "c")
         @mock.random_call("a", "whatever", "c")
       end
 
-      it "should match duck type with one method" do
+      it "matches duck type with one method" do
         @mock.should_receive(:random_call).with(duck_type(:length))
         @mock.random_call([])
       end
 
-      it "should match duck type with two methods" do
+      it "matches duck type with two methods" do
         @mock.should_receive(:random_call).with(duck_type(:abs, :div))
         @mock.random_call(1)
       end
       
-      it "should match no args against any_args()" do
+      it "matches no args against any_args()" do
         @mock.should_receive(:random_call).with(any_args)
         @mock.random_call()
       end
       
-      it "should match one arg against any_args()" do
+      it "matches one arg against any_args()" do
         @mock.should_receive(:random_call).with(any_args)
         @mock.random_call("a string")
       end
       
-      it "should match no args against no_args()" do
+      it "matches no args against no_args()" do
         @mock.should_receive(:random_call).with(no_args)
         @mock.random_call()
       end
       
-      it "should match hash with hash_including same hash" do
+      it "matches hash with hash_including same hash" do
         @mock.should_receive(:random_call).with(hash_including(:a => 1))
         @mock.random_call(:a => 1)
       end
@@ -91,7 +91,7 @@ module RSpec
     describe Methods, "handling block matchers" do
       include_mock_argument_matchers
       
-      it "should match arguments against RSpec expectations" do
+      it "matches arguments against RSpec expectations" do
         @mock.should_receive(:random_call).with {|arg1, arg2, arr, *rest|
           arg1.should == 5
           arg2.should have_at_least(3).characters
@@ -109,33 +109,33 @@ module RSpec
         @mock = RSpec::Mocks::Mock.new("test mock")
       end
       
-      it "should match non special symbol (can be removed when deprecated symbols are removed)" do
+      it "matches non special symbol (can be removed when deprecated symbols are removed)" do
         @mock.should_receive(:random_call).with(:some_symbol)
         @mock.random_call(:some_symbol)
       end
 
-      it "should match string against regexp" do
+      it "matches string against regexp" do
         @mock.should_receive(:random_call).with(/bcd/)
         @mock.random_call("abcde")
       end
 
-      it "should match regexp against regexp" do
+      it "matches regexp against regexp" do
         @mock.should_receive(:random_call).with(/bcd/)
         @mock.random_call(/bcd/)
       end
       
-      it "should match against a hash submitted and received by value" do
+      it "matches against a hash submitted and received by value" do
         @mock.should_receive(:random_call).with(:a => "a", :b => "b")
         @mock.random_call(:a => "a", :b => "b")
       end
       
-      it "should match against a hash submitted by reference and received by value" do
+      it "matches against a hash submitted by reference and received by value" do
         opts = {:a => "a", :b => "b"}
         @mock.should_receive(:random_call).with(opts)
         @mock.random_call(:a => "a", :b => "b")
       end
       
-      it "should match against a hash submitted by value and received by reference" do
+      it "matches against a hash submitted by value and received by reference" do
         opts = {:a => "a", :b => "b"}
         @mock.should_receive(:random_call).with(:a => "a", :b => "b")
         @mock.random_call(opts)