rspec-mocks 2.99.4 → 3.0.0.beta1

data/features/argument_matchers/explicit.feature

@@ -21,7 +21,7 @@ Feature: explicit arguments
 
         it "works on doubles and expectations" do
           object = double('foo')
-          object.should_receive(:bar).with(:foo)
+          expect(object).to receive(:bar).with(:foo)
 
           object.bar(:foo)
         end
@@ -43,17 +43,17 @@ Feature: explicit arguments
             "got this and that"
           end
 
-          object.foo(:this).should eq("got this")
-          object.foo(:this, :that).should eq("got this and that")
+          expect(object.foo(:this)).to eq("got this")
+          expect(object.foo(:this, :that)).to eq("got this and that")
         end
 
         it "works on mocks" do
           object = double('foo')
-          object.should_receive(:foo).with(:this, :that)
+          expect(object).to receive(:foo).with(:this, :that)
 
           object.foo(:this, :that)
         end
       end
       """
     When I run `rspec stub_multiple_explicit_args_spec.rb`
-    Then the output should contain "2 examples, 0 failures"
+    Then the output should contain "2 examples, 0 failures"

data/features/argument_matchers/general_matchers.feature

@@ -15,8 +15,8 @@ Feature: General matchers
             "anything"
           end
 
-          object.foo(1).should eq("anything")
-          object.foo(:that).should eq("anything")
+          expect(object.foo(1)).to eq("anything")
+          expect(object.foo(:that)).to eq("anything")
         end
       end
       """
@@ -33,9 +33,9 @@ Feature: General matchers
             "anything"
           end
 
-          object.foo(1).should eq("anything")
-          object.foo(:that).should eq("anything")
-          object.foo.should eq("anything")
+          expect(object.foo(1)).to eq("anything")
+          expect(object.foo(:that)).to eq("anything")
+          expect(object.foo).to eq("anything")
         end
       end
       """
@@ -55,8 +55,8 @@ Feature: General matchers
             "something"
           end
 
-          object.foo(:that).should eq("something")
-          object.foo.should eq("nothing")
+          expect(object.foo(:that)).to eq("something")
+          expect(object.foo).to eq("nothing")
         end
       end
       """
@@ -69,17 +69,17 @@ Feature: General matchers
       describe "stubbed no_args() args spec for expectations" do
         it "works for no args" do
           object = Object.new
-          object.should_receive(:foo).with(no_args)
+          expect(object).to receive(:foo).with(no_args)
 
           object.foo
         end
         it "fails for args" do
           object = Object.new
-          object.should_receive(:foo).with(no_args)
+          expect(object).to receive(:foo).with(no_args)
 
           object.foo(:bar)
         end
       end
       """
     When I run `rspec stub_no_args_expectations_spec.rb`
-    Then the output should contain "2 examples, 1 failure"
+    Then the output should contain "2 examples, 1 failure"

data/features/argument_matchers/type_matchers.feature

@@ -17,10 +17,10 @@ Feature: stub with argument constraints
             "string"
           end
 
-          object.foo("bar").should eq("string")
-          object.foo(:that).should eq("symbol")
+          expect(object.foo("bar")).to eq("string")
+          expect(object.foo(:that)).to eq("symbol")
         end
       end
       """
     When I run `rspec stub_an_instance_of_args_spec.rb`
-    Then the output should contain "1 example, 0 failures"
+    Then the output should contain "1 example, 0 failures"

data/features/message_expectations/allow_any_instance_of.feature

@@ -7,7 +7,7 @@ Feature: allow a message on any instance of a class
   Scenario: allowing a message on any instance of a class
     Given a file named "example_spec.rb" with:
       """ruby
-      describe "any_instance.should_receive" do
+      describe "any_instance.to receive" do
         before do
           allow_any_instance_of(Object).to receive(:foo).and_return(:return_value)
         end

data/features/message_expectations/any_instance.feature

@@ -1,11 +1,33 @@
 Feature: expect a message on any instance of a class
 
-  Use `any_instance.should_receive` to set an expectation that one (and only
-  one) instance of a class receives a message before the example is completed.
+  Use `expect_any_instance_of(Class).to receive` to set an expectation that one
+  (and only one) instance of a class receives a message before the example is
+  completed.
 
-  The spec will fail if no instance receives a message.
+  The example will fail if no instance receives the specified message.
 
   Scenario: expect a message on any instance of a class
+    Given a file named "example_spec.rb" with:
+    """ruby
+      describe "expect_any_instance_of" do
+        before do
+          expect_any_instance_of(Object).to receive(:foo).and_return(:return_value)
+        end
+
+        it "verifies that one instance of the class receives the message" do
+          o = Object.new
+          expect(o.foo).to eq(:return_value)
+        end
+
+        it "fails unless an instance receives that message" do
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the output should contain "2 examples, 1 failure"
+    And the output should contain "1) expect_any_instance_of fails unless an instance receives that message"
+
+  Scenario: expect a message on any instance of a class (should syntax)
     Given a file named "example_spec.rb" with:
       """ruby
       describe "any_instance.should_receive" do
@@ -13,9 +35,9 @@ Feature: expect a message on any instance of a class
           Object.any_instance.should_receive(:foo).and_return(:return_value)
 
           o = Object.new
-          o.foo.should eq(:return_value)
+          expect(o.foo).to eq(:return_value)
         end
       end
       """
     When I run `rspec example_spec.rb`
-    Then the examples should all pass
+    Then the examples should all pass

data/features/message_expectations/call_original.feature

@@ -14,8 +14,8 @@ Feature: Calling the original method
 
       describe "and_call_original" do
         it "delegates the message to the original implementation" do
-          Addition.should_receive(:two_plus_two).and_call_original
-          Addition.two_plus_two.should eq(4)
+          expect(Addition).to receive(:two_plus_two).and_call_original
+          expect(Addition.two_plus_two).to eq(4)
         end
       end
       """

data/features/message_expectations/expect_message_using_expect.feature

@@ -75,7 +75,7 @@ Feature: expect message using `expect`
           it "returns the specified value" do
             object = double("object")
             expect(object).to receive(:message) { :return_value }
-            object.message.should eq(:return_value)
+            expect(object.message).to eq(:return_value)
           end
         end
 
@@ -83,7 +83,7 @@ Feature: expect message using `expect`
           it "returns the specified value" do
             object = double("object")
             expect(object).to receive(:message).and_return(:return_value)
-            object.message.should eq(:return_value)
+            expect(object.message).to eq(:return_value)
           end
         end
       end

data/features/message_expectations/expect_message_using_should_receive.feature

@@ -84,7 +84,7 @@ Feature: expect message using `should_receive`
           it "returns the specified value" do
             object = double("object")
             object.should_receive(:message) { :return_value }
-            object.message.should eq(:return_value)
+            expect(object.message).to eq(:return_value)
           end
         end
 
@@ -92,7 +92,7 @@ Feature: expect message using `should_receive`
           it "returns the specified value" do
             object = double("object")
             object.should_receive(:message).and_return(:return_value)
-            object.message.should eq(:return_value)
+            expect(object.message).to eq(:return_value)
           end
         end
       end

data/features/message_expectations/receive_counts.feature

@@ -18,7 +18,7 @@ Feature: receive counts
             account = Account.new
             account.logger = logger
 
-            logger.should_receive(:account_opened).once
+            expect(logger).to receive(:account_opened).once
 
             account.open
           end
@@ -46,7 +46,7 @@ Feature: receive counts
             account = Account.new
             account.logger = logger
 
-            logger.should_receive(:account_opened).twice
+            expect(logger).to receive(:account_opened).twice
 
             account.open
             account.open
@@ -75,7 +75,7 @@ Feature: receive counts
             account = Account.new
             account.logger = logger
 
-            logger.should_receive(:account_opened).exactly(3).times
+            expect(logger).to receive(:account_opened).exactly(3).times
 
             account.open
             account.open
@@ -105,7 +105,7 @@ Feature: receive counts
             account = Account.new
             account.logger = logger
 
-            logger.should_receive(:account_opened).at_least(:once)
+            expect(logger).to receive(:account_opened).at_least(:once)
 
             account.open
           end
@@ -134,7 +134,7 @@ Feature: receive counts
             account = Account.new
             account.logger = logger
 
-            logger.should_receive(:account_opened).at_least(3).times
+            expect(logger).to receive(:account_opened).at_least(3).times
 
             # Note that I am calling method under test 4 times
             # and I specified it to be called at least 3 times
@@ -167,7 +167,7 @@ Feature: receive counts
             account = Account.new
             account.logger = logger
 
-            logger.should_receive(:account_opened).at_most(:once)
+            expect(logger).to receive(:account_opened).at_most(:once)
 
             account.open
             account.open
@@ -197,7 +197,7 @@ Feature: receive counts
             account = Account.new
             account.logger = logger
 
-            logger.should_receive(:account_opened).at_most(2).times
+            expect(logger).to receive(:account_opened).at_most(2).times
 
             account.open
             account.open

data/features/message_expectations/warn_when_expectation_is_set_on_nil.feature

@@ -6,7 +6,7 @@ Feature: warn when expectation is set on nil
       RSpec.configure {|c| c.mock_with :rspec}
       describe "something" do
         it "does something" do
-          @i_do_not_exist.should_receive(:foo)
+          expect(@i_do_not_exist).to receive(:foo)
           @i_do_not_exist.foo
         end
       end
@@ -21,7 +21,7 @@ Feature: warn when expectation is set on nil
       describe "something" do
         it "does something" do
           allow_message_expectations_on_nil
-          nil.should_receive(:foo)
+          expect(nil).to receive(:foo)
           nil.foo
         end
       end
@@ -40,7 +40,7 @@ Feature: warn when expectation is set on nil
           nil.foo
         end
         it "does something (bar)" do
-          nil.should_receive(:bar)
+          expect(nil).to receive(:bar)
           nil.bar
         end
       end

data/features/method_stubs/README.md

@@ -65,6 +65,9 @@ You can also use the block format:
     obj.stub(:message).with(anything()) { ... }
     obj.stub(:message).with(an_instance_of(Money)) { ... }
     obj.stub(:message).with(hash_including(:a => 'b')) { ... }
+    obj.stub(:message).with(array_including(1,2,3)) { ... }
+    # or
+    obj.stub(:message).with(array_including([1,2,3])) { ... }
 
 #### Regular expressions
 

data/features/method_stubs/any_instance.feature

@@ -18,7 +18,7 @@ Feature: stub on any instance of a class
           Object.any_instance.stub(:foo).and_return(:return_value)
 
           o = Object.new
-          o.foo.should eq(:return_value)
+          expect(o.foo).to eq(:return_value)
         end
       end
       """
@@ -34,8 +34,8 @@ Feature: stub on any instance of a class
             Object.any_instance.stub(:foo => 'foo', :bar => 'bar')
 
             o = Object.new
-            o.foo.should eq('foo')
-            o.bar.should eq('bar')
+            expect(o.foo).to eq('foo')
+            expect(o.bar).to eq('bar')
           end
         end
       end
@@ -53,8 +53,8 @@ Feature: stub on any instance of a class
             Object.any_instance.stub(:foo).with(:param_three, :param_four).and_return(:result_two)
 
             o = Object.new
-            o.foo(:param_one, :param_two).should eq(:result_one)
-            o.foo(:param_three, :param_four).should eq(:result_two)
+            expect(o.foo(:param_one, :param_two)).to eq(:result_one)
+            expect(o.foo(:param_three, :param_four)).to eq(:result_two)
           end
         end
       end
@@ -76,7 +76,7 @@ Feature: stub on any instance of a class
           Object.any_instance.stub(:foo)
           Object.any_instance.unstub(:foo)
 
-          Object.new.foo.should eq(:foo)
+          expect(Object.new.foo).to eq(:foo)
         end
       end
       """
@@ -94,11 +94,11 @@ Feature: stub on any instance of a class
                 :foo
               end
             end
-            Object.any_instance.should_receive(:foo).and_return(:bar)
+            expect_any_instance_of(Object).to receive(:foo).and_return(:bar)
             Object.any_instance.stub(:foo)
             Object.any_instance.unstub(:foo)
 
-            Object.new.foo.should eq(:bar)
+            expect(Object.new.foo).to eq(:bar)
           end
         end
       end
@@ -113,21 +113,21 @@ Feature: stub on any instance of a class
         context "given symbols representing methods" do
           it "returns the correct value" do
             Object.any_instance.stub_chain(:one, :two, :three).and_return(:four)
-            Object.new.one.two.three.should eq(:four)
+            expect(Object.new.one.two.three).to eq(:four)
           end
         end
 
         context "given a hash at the end" do
           it "returns the correct value" do
             Object.any_instance.stub_chain(:one, :two, :three => :four)
-            Object.new.one.two.three.should eq(:four)
+            expect(Object.new.one.two.three).to eq(:four)
           end
         end
 
         context "given a string of methods separated by dots" do
           it "returns the correct value" do
             Object.any_instance.stub_chain("one.two.three").and_return(:four)
-            Object.new.one.two.three.should eq(:four)
+            expect(Object.new.one.two.three).to eq(:four)
           end
         end
       end

data/features/method_stubs/as_null_object.feature

@@ -13,7 +13,7 @@ Feature: as_null_object
         let(:null_object) { double('null object').as_null_object }
 
         it "responds to any method that is not defined" do
-          null_object.should respond_to(:an_undefined_method)
+          expect(null_object).to respond_to(:an_undefined_method)
         end
 
         it "allows explicit stubs using expect syntax" do
@@ -23,16 +23,16 @@ Feature: as_null_object
 
         it "allows explicit stubs using should syntax" do
           null_object.stub(:foo) { "bar" }
-          null_object.foo.should eq("bar")
+          expect(null_object.foo).to eq("bar")
         end
 
         it "allows explicit expectations" do
-          null_object.should_receive(:something)
+          expect(null_object).to receive(:something)
           null_object.something
         end
 
         it "supports Array#flatten" do
-          [null_object].flatten.should eq([null_object])
+          expect([null_object].flatten).to eq([null_object])
         end
       end
       """

data/features/method_stubs/simple_return_value_with_stub.feature

@@ -12,7 +12,7 @@ Feature: stub with a simple return value
 
         it "returns nil" do
           collaborator.stub(:message)
-          collaborator.message.should be(nil)
+          expect(collaborator.message).to be(nil)
         end
       end
       """
@@ -27,7 +27,7 @@ Feature: stub with a simple return value
           it "returns the specified value" do
             collaborator = double("collaborator")
             collaborator.stub(:message) { :value }
-            collaborator.message.should eq(:value)
+            expect(collaborator.message).to eq(:value)
           end
         end
 
@@ -35,7 +35,7 @@ Feature: stub with a simple return value
           it "returns the specified value" do
             collaborator = double("collaborator")
             collaborator.stub(:message).and_return(:value)
-            collaborator.message.should eq(:value)
+            expect(collaborator.message).to eq(:value)
           end
         end
 
@@ -43,8 +43,8 @@ Feature: stub with a simple return value
           it "returns the specified value" do
             collaborator = double("collaborator")
             collaborator.stub(:message_1 => :value_1, :message_2 => :value_2)
-            collaborator.message_1.should eq(:value_1)
-            collaborator.message_2.should eq(:value_2)
+            expect(collaborator.message_1).to eq(:value_1)
+            expect(collaborator.message_2).to eq(:value_2)
           end
         end
 
@@ -54,8 +54,8 @@ Feature: stub with a simple return value
               :message_1 => :value_1,
               :message_2 => :value_2
             )
-            collaborator.message_1.should eq(:value_1)
-            collaborator.message_2.should eq(:value_2)
+            expect(collaborator.message_1).to eq(:value_1)
+            expect(collaborator.message_2).to eq(:value_2)
           end
         end
       end