rspec-mocks 2.99.4 → 3.0.0.beta1

data/features/method_stubs/stub_chain.feature

@@ -28,21 +28,21 @@ Feature: stub a chain of methods
         context "given symbols representing methods" do
           it "returns the correct value" do
             subject.stub_chain(:one, :two, :three).and_return(:four)
-            subject.one.two.three.should eq(:four)
+            expect(subject.one.two.three).to eq(:four)
           end
         end
 
         context "given a hash at the end" do
           it "returns the correct value" do
             subject.stub_chain(:one, :two, :three => :four)
-            subject.one.two.three.should eq(:four)
+            expect(subject.one.two.three).to eq(:four)
           end
         end
 
         context "given a string of methods separated by dots" do
           it "returns the correct value" do
             subject.stub_chain("one.two.three").and_return(:four)
-            subject.one.two.three.should eq(:four)
+            expect(subject.one.two.three).to eq(:four)
           end
         end
       end

data/features/method_stubs/stub_implementation.feature

@@ -39,8 +39,8 @@ Feature: stub with substitute implementation
             end
           end
 
-          object.foo(:this).should eq("got this")
-          object.foo(:that).should eq("got that")
+          expect(object.foo(:this)).to eq("got this")
+          expect(object.foo(:that)).to eq("got that")
         end
       end
       """

data/features/method_stubs/to_ary.feature

@@ -19,12 +19,12 @@ Feature: double handling to_ary
         shared_examples "to_ary" do
           it "can be overridden with a stub" do
             obj.stub(:to_ary) { :non_nil_value }
-            obj.to_ary.should be(:non_nil_value)
+            expect(obj.to_ary).to be(:non_nil_value)
           end
 
           it "supports Array#flatten" do
             obj = double('foo')
-            [obj].flatten.should eq([obj])
+            expect([obj].flatten).to eq([obj])
           end
         end
 

data/features/mutating_constants/hiding_defined_constant.feature

@@ -14,7 +14,7 @@ Feature: Hide Defined Constant
         end
 
         it "restores the hidden constant when the example completes" do
-          FOO.should eq(7)
+          expect(FOO).to eq(7)
         end
       end
       """
@@ -38,7 +38,7 @@ Feature: Hide Defined Constant
           end
 
           it "restores the hidden constant when the example completes" do
-            MyGem::SomeClass::FOO.should eq(7)
+            expect(MyGem::SomeClass::FOO).to eq(7)
           end
         end
       end

data/features/mutating_constants/stub_defined_constant.feature

@@ -12,11 +12,11 @@ Feature: Stub Defined Constant
       describe "stubbing FOO" do
         it "can stub FOO with a different value" do
           stub_const("FOO", 5)
-          FOO.should eq(5)
+          expect(FOO).to eq(5)
         end
 
         it "restores the stubbed constant when the example completes" do
-          FOO.should eq(7)
+          expect(FOO).to eq(7)
         end
       end
       """
@@ -36,7 +36,7 @@ Feature: Stub Defined Constant
         describe SomeClass do
           it "stubs the nested constant when it is fully qualified" do
             stub_const("MyGem::SomeClass::FOO", 5)
-            SomeClass::FOO.should eq(5)
+            expect(SomeClass::FOO).to eq(5)
           end
         end
       end
@@ -64,12 +64,12 @@ Feature: Stub Defined Constant
 
           it "transfers nested constants when using :transfer_nested_constants => true" do
             stub_const("MyGem::SomeClass", fake_class, :transfer_nested_constants => true)
-            SomeClass::FOO.should eq(7)
+            expect(SomeClass::FOO).to eq(7)
           end
 
           it "can specify a list of nested constants to transfer" do
             stub_const("MyGem::SomeClass", fake_class, :transfer_nested_constants => [:FOO])
-            SomeClass::FOO.should eq(7)
+            expect(SomeClass::FOO).to eq(7)
           end
         end
       end

data/features/mutating_constants/stub_undefined_constant.feature

@@ -11,7 +11,7 @@ Feature: Stub Undefined Constant
       describe "stubbing FOO" do
         it "can stub undefined constant FOO" do
           stub_const("FOO", 5)
-          FOO.should eq(5)
+          expect(FOO).to eq(5)
         end
 
         it "undefines the constant when the example completes" do
@@ -33,15 +33,15 @@ Feature: Stub Undefined Constant
       module MyGem
         describe SomeClass do
           it "can stub an arbitrarily deep constant that is undefined" do
-            defined?(SomeClass::A).should be_false
+            expect(defined?(SomeClass::A)).to be_falsey
             stub_const("MyGem::SomeClass::A::B::C", 3)
-            SomeClass::A::B::C.should eq(3)
-            SomeClass::A.should be_a(Module)
+            expect(SomeClass::A::B::C).to eq(3)
+            expect(SomeClass::A).to be_a(Module)
           end
 
           it 'undefines the intermediary constants that were dynamically created' do
-            defined?(SomeClass).should be_true
-            defined?(SomeClass::A).should be_false
+            expect(defined?(SomeClass)).to be_truthy
+            expect(defined?(SomeClass::A)).to be_falsey
           end
         end
       end

data/features/outside_rspec/configuration.feature

@@ -34,8 +34,6 @@ Feature: configure any test framework to use rspec-mocks
       example.init
 
       puts example.respond_to?(:double)
-      puts example.respond_to?(:mock)
-      puts example.respond_to?(:stub)
       """
 
     When I run `ruby foo.rb`

data/features/outside_rspec/standalone.feature

@@ -22,7 +22,7 @@ Feature: standalone
       require "rspec/mocks/standalone"
 
       greeter = double("greeter")
-      greeter.should_receive(:say_hi)
+      expect(greeter).to receive(:say_hi)
 
       RSpec::Mocks.verify
       """

data/features/spies/spy_partial_mock_method.feature

@@ -11,7 +11,7 @@ Feature: Spy on a stubbed method on a partial mock
           invitation = Object.new
           invitation.stub(:deliver => true)
           invitation.deliver
-          invitation.should have_received(:deliver)
+          expect(invitation).to have_received(:deliver)
         end
       end
       """
@@ -25,7 +25,7 @@ Feature: Spy on a stubbed method on a partial mock
         it "fails when the expectation is not met" do
           invitation = Object.new
           invitation.stub(:deliver => true)
-          invitation.should have_received(:deliver)
+          expect(invitation).to have_received(:deliver)
         end
       end
       """

data/features/spies/spy_pure_mock_method.feature

@@ -10,7 +10,7 @@ Feature: Spy on a stubbed method on a pure mock
         it "passes when the expectation is met" do
           invitation = double('invitation', :deliver => true)
           invitation.deliver
-          invitation.should have_received(:deliver)
+          expect(invitation).to have_received(:deliver)
         end
       end
       """
@@ -24,7 +24,7 @@ Feature: Spy on a stubbed method on a pure mock
         it "passes when the expectation is met" do
           invitation = double('invitation', :deliver => true)
           2.times { invitation.deliver(:expected, :arguments) }
-          invitation.should have_received(:deliver).
+          expect(invitation).to have_received(:deliver).
             with(:expected, :arguments).
             twice
         end
@@ -39,7 +39,7 @@ Feature: Spy on a stubbed method on a pure mock
       describe "have_received" do
         it "fails when the expectation is not met" do
           invitation = double('invitation', :deliver => true)
-          invitation.should have_received(:deliver)
+          expect(invitation).to have_received(:deliver)
         end
       end
       """
@@ -54,7 +54,7 @@ Feature: Spy on a stubbed method on a pure mock
         it "fails when the arguments are different" do
           invitation = double('invitation', :deliver => true)
           invitation.deliver(:unexpected)
-          invitation.should have_received(:deliver).with(:expected, :arguments)
+          expect(invitation).to have_received(:deliver).with(:expected, :arguments)
         end
       end
       """
@@ -66,7 +66,7 @@ Feature: Spy on a stubbed method on a pure mock
     Given a file named "spy_message_spec.rb" with:
       """ruby
       describe "have_received" do
-        subject(:invitation) { double('invitation', :deliver => true) }
+      subject(:invitation) { double('invitation', :deliver => true) }
         before { invitation.deliver }
 
         it { should have_received(:deliver) }

data/features/spies/spy_unstubbed_method.feature

@@ -10,7 +10,7 @@ Feature: Spy on an unstubbed method
         it "raises a helpful error for unstubbed methods" do
           object = Object.new
           object.object_id
-          object.should have_received(:object_id)
+          expect(object).to have_received(:object_id)
         end
       end
       """

data/features/support/env.rb

@@ -2,7 +2,11 @@ require 'aruba/cucumber'
 require 'rspec/expectations'
 
 Before do
-  RUBY_PLATFORM =~ /java/ ? @aruba_timeout_seconds = 60 : @aruba_timeout_seconds = 5
+  if RUBY_PLATFORM =~ /java/ || defined?(Rubinius)
+    @aruba_timeout_seconds = 60
+  else
+    @aruba_timeout_seconds = 5
+  end
 end
 
 Aruba.configure do |config|
@@ -11,3 +15,8 @@ Aruba.configure do |config|
   end
 end if RUBY_PLATFORM == 'java'
 
+Aruba.configure do |config|
+  config.before_cmd do |cmd|
+    set_env('RBXOPT', "-Xint=true #{ENV['RBXOPT']}") # disable JIT since these processes are so short lived
+  end
+end if defined?(Rubinius)

data/features/test_frameworks/test_unit.feature

@@ -40,4 +40,4 @@ Feature: Test::Unit integration
      When I run `ruby rspec_mocks_test.rb`
      Then the output should contain "3 tests, 0 assertions, 0 failures, 1 errors" or "3 tests, 0 assertions, 1 failures, 0 errors"
      And the output should contain "expected: 0 times with any arguments"
-     And the output should contain "old_message is deprecated. Use message instead."
+     And the output should contain "old_message is deprecated"

data/features/verifying_doubles/class_doubles.feature

@@ -0,0 +1,88 @@
+Feature: Using a class double
+
+  `class_double` is provided as a complement to `instance_double`, with the
+  difference that it verifies class methods on the given class rather than
+  instance methods.
+
+  In addition, it also provides a convenience method `as_stubbed_const` to
+  replace concrete classes with the defined double. See [mutating
+  constants](../mutating-constants) for more details.
+
+  Note: `class_double` can be used for modules as well. We chose to stick with
+  the `class_double` terminology because the methods a `class_double` verifies
+  against are commonly called "class methods", not "module methods", even when
+  working with a module.
+
+  Background:
+    Given a file named "lib/user.rb" with:
+      """ruby
+      class User
+        def suspend!
+          ConsoleNotifier.notify("suspended as")
+        end
+      end
+      """
+
+    Given a file named "lib/console_notifier.rb" with:
+      """ruby
+      class ConsoleNotifier
+        MAX_WIDTH = 80
+
+        def self.notify(message)
+          puts message
+        end
+      end
+      """
+
+    Given a file named "spec/user_spec.rb" with:
+      """ruby
+      require 'user'
+      require 'console_notifier'
+
+      describe User, '#suspend!' do
+        it 'notifies the console' do
+          notifier = class_double("ConsoleNotifier").
+            as_stubbed_const(:transfer_nested_constants => true)
+
+          expect(notifier).to receive(:notify).with("suspended as")
+          expect(ConsoleNotifier::MAX_WIDTH).to eq(80)
+
+          user = User.new
+          user.suspend!
+        end
+      end
+      """
+
+  Scenario: replacing existing constants
+    When I run `rspec spec/user_spec.rb`
+    Then the examples should all pass
+
+  Scenario: renaming `ConsoleNotifier.notify` to `send_notification`
+    Given a file named "lib/console_notifier.rb" with:
+      """ruby
+      class ConsoleNotifier
+        MAX_WIDTH = 80
+
+        def self.send_notification(message)
+          puts message
+        end
+      end
+      """
+    When I run `rspec spec/user_spec.rb`
+    Then the output should contain "1 example, 1 failure"
+    And the output should contain "ConsoleNotifier does not implement:"
+
+  Scenario: adding `color` as a second argument to `ConsoleNotifier.notify`
+    Given a file named "lib/console_notifier.rb" with:
+      """ruby
+      class ConsoleNotifier
+        MAX_WIDTH = 80
+
+        def self.notify(message, color)
+          puts color + message
+        end
+      end
+      """
+    When I run `rspec spec/user_spec.rb`
+    Then the output should contain "1 example, 1 failure"
+     And the output should contain "Wrong number of arguments."

data/features/verifying_doubles/dynamic_classes.feature

@@ -0,0 +1,72 @@
+Feature: Dynamic classes
+
+  Verifying instance doubles do not support methods which the class reports to
+  not exist since an actual instance of the class would be required to verify
+  against.  This is commonly the case when `method_missing` is used.
+  `ActiveRecord` does this to define methods from database columns.  If the
+  object has already been loaded you may consider using an `object_double`, but
+  that cannot work if you are testing in isolation.
+
+  These types of methods are supported at class level, since `respond_to?` can
+  be queried directly on the class.
+
+
+  Background:
+    Given a file named "lib/fake_active_record.rb" with:
+      """ruby
+      class FakeActiveRecord
+        COLUMNS = %w[name email]
+
+        def respond_to_missing?(method_name)
+          COLUMNS.include?(method_name.to_s) || super
+        end
+
+        def method_missing(method_name, *args)
+          if respond_to?(method_name)
+            instance_variable_get("@#{method_name}")
+          else
+            super
+          end
+        end
+      end
+      """
+
+    Given a file named "spec/user_spec.rb" with:
+      """ruby
+      require 'user'
+
+      describe User do
+        it 'can be doubled' do
+          instance_double("User", :name => "Don")
+        end
+      end
+      """
+
+  Scenario: fails with method missing
+
+    Given a file named "lib/user.rb" with:
+      """ruby
+      require 'fake_active_record'
+
+      class User < FakeActiveRecord
+      end
+      """
+
+    When I run `rspec spec/user_spec.rb`
+    Then the output should contain "1 example, 1 failure"
+
+  Scenario: workaround with explict definitions
+
+    Given a file named "lib/user.rb" with:
+      """ruby
+      require 'fake_active_record'
+
+      class User < FakeActiveRecord
+        def name;  super end
+        def email; super end
+      end
+      """
+
+    When I run `rspec spec/user_spec.rb`
+    Then the examples should all pass
+

data/features/verifying_doubles/introduction.feature

@@ -0,0 +1,85 @@
+Feature: Verifying doubles
+
+  Verifying doubles are a stricter alternative to normal doubles that provide
+  guarantees about what is being verified.  When using verifying doubles, RSpec
+  will check that the methods being stubbed are actually present on the
+  underlying object if it is available. Prefer using veryifing doubles over
+  normal doubles.
+
+  No checking will happen if the constant name is not defined, but when run
+  with the constant present (either as a full spec run or by explicitly
+  preloading collaborators) a failure will be triggered if an invalid method is
+  being stubbed.
+
+  This dual approach allows you to move very quickly and test components in
+  isolation, while giving you confidence that your doubles are not a complete
+  fiction. Testing in isolation is optional but recommend for classes that do
+  not depend on third-party components.
+
+  Background:
+    Given a file named "app/models/user.rb" with:
+      """ruby
+      class User < Struct.new(:notifier)
+        def suspend!
+          notifier.notify("suspended as")
+        end
+      end
+      """
+
+    Given a file named "app/models/console_notifier.rb" with:
+      """ruby
+      class ConsoleNotifier
+        # notify is not defined yet.
+      end
+      """
+
+    Given a file named "spec/unit_helper.rb" with:
+      """ruby
+      $LOAD_PATH.unshift("app/models")
+      """
+
+    Given a file named "spec/spec_helper.rb" with:
+      """ruby
+      require 'unit_helper'
+
+      require 'user'
+      require 'console_notifier'
+
+      RSpec.configure do |config|
+        config.mock_with :rspec do |mocks|
+
+          # This option should be set when all dependencies are being loaded
+          # before a spec run, as is the case in a typical spec helper. It will
+          # cause any verifying double instantiation for a class that does not
+          # exist to raise, protecting against incorrectly spelt names.
+          mocks.verify_doubled_constant_names = true
+
+        end
+      end
+      """
+
+    Given a file named "spec/unit/user_spec.rb" with:
+      """ruby
+      require 'unit_helper'
+
+      require 'user'
+
+      describe User, '#suspend!' do
+        it 'notifies the console' do
+          notifier = instance_double("ConsoleNotifier")
+
+          expect(notifier).to receive(:notify).with("suspended as")
+
+          user = User.new(notifier)
+          user.suspend!
+        end
+      end
+      """
+
+  Scenario: spec passes in isolation
+    When I run `rspec spec/unit/user_spec.rb`
+    Then the examples should all pass
+
+  Scenario: spec fails with dependencies loaded
+    When I run `rspec -r./spec/spec_helper spec/unit/user_spec.rb`
+    Then the output should contain "1 example, 1 failure"