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

data/spec/rspec/mocks/at_most_spec.rb

@@ -7,7 +7,7 @@ module RSpec
         @mock = RSpec::Mocks::Mock.new("test mock")
       end
 
-      it "should fail when at most n times method is called n plus 1 times" do
+      it "fails when at most n times method is called n plus 1 times" do
         @mock.should_receive(:random_call).at_most(4).times
         @mock.random_call
         @mock.random_call
@@ -19,7 +19,7 @@ module RSpec
         end.should raise_error(RSpec::Mocks::MockExpectationError)
       end
 
-      it "should fail when at most once method is called twice" do
+      it "fails when at most once method is called twice" do
         @mock.should_receive(:random_call).at_most(:once)
         @mock.random_call
         @mock.random_call
@@ -28,7 +28,7 @@ module RSpec
         end.should raise_error(RSpec::Mocks::MockExpectationError)
       end
 
-      it "should fail when at most twice method is called three times" do
+      it "fails when at most twice method is called three times" do
         @mock.should_receive(:random_call).at_most(:twice)
         @mock.random_call
         @mock.random_call
@@ -38,7 +38,7 @@ module RSpec
         end.should raise_error(RSpec::Mocks::MockExpectationError)
       end
 
-      it "should pass when at most n times method is called exactly n times" do
+      it "passes when at most n times method is called exactly n times" do
         @mock.should_receive(:random_call).at_most(4).times
         @mock.random_call
         @mock.random_call
@@ -47,7 +47,7 @@ module RSpec
         @mock.rspec_verify
       end
 
-      it "should pass when at most n times method is called less than n times" do
+      it "passes when at most n times method is called less than n times" do
         @mock.should_receive(:random_call).at_most(4).times
         @mock.random_call
         @mock.random_call
@@ -55,36 +55,36 @@ module RSpec
         @mock.rspec_verify
       end
 
-      it "should pass when at most n times method is never called" do
+      it "passes when at most n times method is never called" do
         @mock.should_receive(:random_call).at_most(4).times
         @mock.rspec_verify
       end
 
-      it "should pass when at most once method is called once" do
+      it "passes when at most once method is called once" do
         @mock.should_receive(:random_call).at_most(:once)
         @mock.random_call
         @mock.rspec_verify
       end
 
-      it "should pass when at most once method is never called" do
+      it "passes when at most once method is never called" do
         @mock.should_receive(:random_call).at_most(:once)
         @mock.rspec_verify
       end
 
-      it "should pass when at most twice method is called once" do
+      it "passes when at most twice method is called once" do
         @mock.should_receive(:random_call).at_most(:twice)
         @mock.random_call
         @mock.rspec_verify
       end
 
-      it "should pass when at most twice method is called twice" do
+      it "passes when at most twice method is called twice" do
         @mock.should_receive(:random_call).at_most(:twice)
         @mock.random_call
         @mock.random_call
         @mock.rspec_verify
       end
 
-      it "should pass when at most twice method is never called" do
+      it "passes when at most twice method is never called" do
         @mock.should_receive(:random_call).at_most(:twice)
         @mock.rspec_verify
       end

data/spec/rspec/mocks/bug_report_10260_spec.rb

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

data/spec/rspec/mocks/bug_report_11545_spec.rb

@@ -15,17 +15,17 @@ describe 'should_receive' do
     @liar = LiarLiarPantsOnFire.new
   end
   
-  it "should work when object lies about responding to a method" do
+  it "works when object lies about responding to a method" do
     @liar.should_receive(:something)
     @liar.something
   end
 
-  it 'should work when class lies about responding to a method' do
+  it 'works when class lies about responding to a method' do
     LiarLiarPantsOnFire.should_receive(:something)
     LiarLiarPantsOnFire.something
   end
   
-  it 'should cleanup after itself' do
+  it 'cleans up after itself' do
     (class << LiarLiarPantsOnFire; self; end).instance_methods.should_not include("something")
   end
 end

data/spec/rspec/mocks/bug_report_15719_spec.rb

@@ -4,7 +4,7 @@ module RSpec
   module Mocks
     describe "mock failure" do
       
-      it "should tell you when it receives the right message with the wrong args" do
+      it "tells you when it receives the right message with the wrong args" do
         double = double("foo")
         double.should_receive(:bar).with("message")
         lambda {
@@ -13,7 +13,7 @@ module RSpec
         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
+      pending "tells 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.
         double = double("foo")

data/spec/rspec/mocks/bug_report_600_spec.rb

@@ -10,12 +10,12 @@ module BugReport600
       end
     end
  
-    it "should work" do
+    it "works" do
       ExampleClass.should_receive(:define_method).with("defined_method")
       ExampleClass.method_that_uses_define_method
     end
 
-    it "should restore the original method" do
+    it "restores the original method" do
       ExampleClass.method_that_uses_define_method
     end
   end

data/spec/rspec/mocks/bug_report_7611_spec.rb

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

data/spec/rspec/mocks/bug_report_8165_spec.rb

@@ -12,7 +12,7 @@ describe "An object where respond_to? is true and does not have method" do
   # The fix was to keep track of whether :respond_to? had been proxied and, if
   # so, call the munged copy of :respond_to? on the object.
 
-  it "should not raise an exception for Object" do
+  it "does not raise an exception for Object" do
     obj = Object.new
     obj.should_receive(:respond_to?).with(:foobar).and_return(true)
     obj.should_receive(:foobar).and_return(:baz)
@@ -20,7 +20,7 @@ describe "An object where respond_to? is true and does not have method" do
     obj.foobar.should == :baz
   end
 
-  it "should not raise an exception for mock" do
+  it "does not raise an exception for mock" do
     obj = double("obj")
     obj.should_receive(:respond_to?).with(:foobar).and_return(true)
     obj.should_receive(:foobar).and_return(:baz)

data/spec/rspec/mocks/bug_report_957_spec.rb

@@ -10,11 +10,11 @@ module RSpec
         @base_class.stub(:find).and_return "stubbed_value"
       end
 
-      it "should return the value for the stub on the base class" do
+      it "returns the value for the stub on the base class" do
         @base_class.find.should == "stubbed_value"
       end
 
-      it "should return the value for the descendent class" do
+      it "returns the value for the descendent class" do
         @concrete_class.find.should == "stubbed_value"
       end
     end

data/spec/rspec/mocks/failing_argument_matchers_spec.rb

@@ -12,78 +12,78 @@ module RSpec
         @mock.rspec_reset
       end
 
-      it "should reject non boolean" do
+      it "rejects non boolean" do
         @mock.should_receive(:random_call).with(boolean())
         lambda do
           @mock.random_call("false")
         end.should raise_error(RSpec::Mocks::MockExpectationError)
       end
 
-      it "should reject non numeric" do
+      it "rejects 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
       
-      it "should reject non string" do
+      it "rejects 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
       
-      it "should reject goose when expecting a duck" do
+      it "rejects 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)
       end
 
-      it "should fail if regexp does not match submitted string" do
+      it "fails 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)
       end
       
-      it "should fail if regexp does not match submitted regexp" do
+      it "fails 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)
       end
       
-      it "should fail for a hash w/ wrong values" do
+      it "fails 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
       
-      it "should fail for a hash w/ wrong keys" do
+      it "fails 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
       
-      it "should match against a Matcher" do
+      it "matches 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
       
-      it "should fail no_args with one arg" do
+      it "fails 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
       
-      it "should fail hash_including with missing key" do
+      it "fails 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
 
-      it "should fail with block matchers" do
+      it "fails with block matchers" do
         lambda do
           @mock.should_receive(:msg).with {|arg| arg.should == :received }
           @mock.msg :no_msg_for_you

data/spec/rspec/mocks/hash_including_matcher_spec.rb

@@ -5,82 +5,82 @@ module RSpec
     module ArgumentMatchers
       describe HashIncludingMatcher do
         
-        it "should describe itself properly" do
+        it "describes itself properly" do
           HashIncludingMatcher.new(:a => 1).description.should == "hash_including(:a=>1)"
         end      
 
         describe "passing" do
-          it "should match the same hash" do
+          it "matches the same hash" do
             hash_including(:a => 1).should == {:a => 1}
           end
 
-          it "should match a hash with extra stuff" do
+          it "matches a hash with extra stuff" do
             hash_including(:a => 1).should == {:a => 1, :b => 2}
           end
           
           describe "when matching against other matchers" do
-            it "should match an int against anything()" do
+            it "matches an int against anything()" do
               hash_including(:a => anything, :b => 2).should == {:a => 1, :b => 2}
             end
 
-            it "should match a string against anything()" do
+            it "matches a string against anything()" do
               hash_including(:a => anything, :b => 2).should == {:a => "1", :b => 2}
             end
           end
           
           describe "when passed only keys or keys mixed with key/value pairs" do
-            it "should match if the key is present" do
+            it "matches if the key is present" do
               hash_including(:a).should == {:a => 1, :b => 2}
             end
             
-            it "should match if more keys are present" do
+            it "matches if more keys are present" do
               hash_including(:a, :b).should == {:a => 1, :b => 2, :c => 3}
             end
 
-            it "should match a string against a given key" do
+            it "matches a string against a given key" do
               hash_including(:a).should == {:a => "1", :b => 2}
             end
 
-            it "should match if passed one key and one key/value pair" do
+            it "matches if passed one key and one key/value pair" do
               hash_including(:a, :b => 2).should == {:a => 1, :b => 2}
             end
             
-            it "should match if passed many keys and one key/value pair" do
+            it "matches if passed many keys and one key/value pair" do
               hash_including(:a, :b, :c => 3).should == {:a => 1, :b => 2, :c => 3, :d => 4}
             end
             
-            it "should match if passed many keys and many key/value pairs" do
+            it "matches if passed many keys and many key/value pairs" do
               hash_including(:a, :b, :c => 3, :e => 5).should == {:a => 1, :b => 2, :c => 3, :d => 4, :e => 5}
             end
           end
         end
         
         describe "failing" do
-          it "should not match a non-hash" do
+          it "does not match a non-hash" do
             hash_including(:a => 1).should_not == 1
           end
 
-          it "should not match a hash with a missing key" do
+          it "does not match a hash with a missing key" do
             hash_including(:a => 1).should_not == {:b => 2}
           end
           
-          it "should not match a hash with a missing key" do
+          it "does not match a hash with a missing key" do
             hash_including(:a).should_not == {:b => 2}
           end
           
-          it "should not match an empty hash with a given key" do
+          it "does not match an empty hash with a given key" do
             hash_including(:a).should_not == {}
           end
           
-          it "should not match a hash with a missing key when one pair is matching" do
+          it "does not match a hash with a missing key when one pair is matching" do
             hash_including(:a, :b => 2).should_not == {:b => 2}
           end
           
-          it "should not match a hash with an incorrect value" do
+          it "does not match a hash with an incorrect value" do
             hash_including(:a => 1, :b => 2).should_not == {:a => 1, :b => 3}
           end
 
-          it "should not match when values are nil but keys are different" do
+          it "does not match when values are nil but keys are different" do
             hash_including(:a => nil).should_not == {:b => nil}
           end
         end

data/spec/rspec/mocks/hash_not_including_matcher_spec.rb

@@ -5,59 +5,59 @@ module RSpec
     module ArgumentMatchers
       describe HashNotIncludingMatcher do
         
-        it "should describe itself properly" do
+        it "describes itself properly" do
           HashNotIncludingMatcher.new(:a => 5).description.should == "hash_not_including(:a=>5)"
         end      
 
         describe "passing" do
-          it "should match a hash without the specified key" do
+          it "matches a hash without the specified key" do
             hash_not_including(:c).should == {:a => 1, :b => 2}
           end
           
-          it "should match a hash with the specified key, but different value" do
+          it "matches a hash with the specified key, but different value" do
             hash_not_including(:b => 3).should == {:a => 1, :b => 2}
           end
                     
-          it "should match a hash without the specified key, given as anything()" do
+          it "matches a hash without the specified key, given as anything()" do
             hash_not_including(:c => anything).should == {:a => 1, :b => 2}
           end
 
-          it "should match an empty hash" do
+          it "matches an empty hash" do
             hash_not_including(:a).should == {}
           end
           
-          it "should match a hash without any of the specified keys" do
+          it "matches a hash without any of the specified keys" do
             hash_not_including(:a, :b, :c).should == { :d => 7}
           end
           
         end
         
         describe "failing" do
-          it "should not match a non-hash" do
+          it "does not match a non-hash" do
             hash_not_including(:a => 1).should_not == 1
           end
           
-          it "should not match a hash with a specified key" do
+          it "does not match a hash with a specified key" do
             hash_not_including(:b).should_not == {:b => 2}
           end
           
-          it "should not match a hash with the specified key/value pair" do
+          it "does not match a hash with the specified key/value pair" do
             hash_not_including(:b => 2).should_not == {:a => 1, :b => 2}
           end
           
-          it "should not match a hash with the specified key" do
+          it "does not match a hash with the specified key" do
             hash_not_including(:a, :b => 3).should_not == {:a => 1, :b => 2}
           end
           
-          it "should not match a hash with one of the specified keys" do
+          it "does not match a hash with one of the specified keys" do
             hash_not_including(:a, :b).should_not == {:b => 2}
           end
           
-          it "should not match a hash with some of the specified keys" do
+          it "does not match a hash with some of the specified keys" do
             hash_not_including(:a, :b, :c).should_not == {:a => 1, :b => 2}
           end
           
-          it "should not match a hash with one key/value pair included" do
+          it "does not match a hash with one key/value pair included" do
             hash_not_including(:a, :b, :c, :d => 7).should_not == { :d => 7}
           end
         end