rspec-mocks 3.0.0.beta2 → 3.0.0.rc1

data/features/spies/spy_pure_mock_method.feature

@@ -1,76 +0,0 @@
-Feature: Spy on a stubbed method on a pure mock
-
-  You can use `have_received` to verify that a stubbed method was invoked,
-  rather than setting an expectation for it to be invoked beforehand.
-
-  Scenario: verify a stubbed method
-    Given a file named "verified_spy_spec.rb" with:
-      """ruby
-      describe "have_received" do
-        it "passes when the expectation is met" do
-          invitation = double('invitation', :deliver => true)
-          invitation.deliver
-          expect(invitation).to have_received(:deliver)
-        end
-      end
-      """
-    When I run `rspec verified_spy_spec.rb`
-    Then the examples should all pass
-
-  Scenario: verify a stubbed method with message expectations
-    Given a file named "verified_message_expectations_spec.rb" with:
-      """ruby
-      describe "have_received" do
-        it "passes when the expectation is met" do
-          invitation = double('invitation', :deliver => true)
-          2.times { invitation.deliver(:expected, :arguments) }
-          expect(invitation).to have_received(:deliver).
-            with(:expected, :arguments).
-            twice
-        end
-      end
-      """
-    When I run `rspec verified_message_expectations_spec.rb`
-    Then the examples should all pass
-
-  Scenario: fail to verify a stubbed method
-    Given a file named "failed_spy_spec.rb" with:
-      """ruby
-      describe "have_received" do
-        it "fails when the expectation is not met" do
-          invitation = double('invitation', :deliver => true)
-          expect(invitation).to have_received(:deliver)
-        end
-      end
-      """
-    When I run `rspec failed_spy_spec.rb`
-    Then the output should contain "expected: 1 time"
-     And the output should contain "received: 0 times"
-
-  Scenario: fail to verify message expectations
-    Given a file named "failed_message_expectations_spec.rb" with:
-      """ruby
-      describe "have_received" do
-        it "fails when the arguments are different" do
-          invitation = double('invitation', :deliver => true)
-          invitation.deliver(:unexpected)
-          expect(invitation).to have_received(:deliver).with(:expected, :arguments)
-        end
-      end
-      """
-    When I run `rspec failed_message_expectations_spec.rb`
-    Then the output should contain "expected: (:expected, :arguments)"
-    And the output should contain "got: (:unexpected)"
-
-  Scenario: generate a spy message
-    Given a file named "spy_message_spec.rb" with:
-      """ruby
-      describe "have_received" do
-        subject(:invitation) { double('invitation', :deliver => true) }
-        before { invitation.deliver }
-
-        it { should have_received(:deliver) }
-      end
-      """
-    When I run `rspec --format documentation spy_message_spec.rb`
-    Then the output should contain "should have received deliver"

data/features/spies/spy_unstubbed_method.feature

@@ -1,18 +0,0 @@
-Feature: Spy on an unstubbed method
-
-  Using have_received on an unstubbed method will never pass, so rspec-mocks
-  issues a helpful error message.
-
-  Scenario: fail to verify a stubbed method
-    Given a file named "failed_spy_spec.rb" with:
-      """ruby
-      describe "have_received" do
-        it "raises a helpful error for unstubbed methods" do
-          object = Object.new
-          object.object_id
-          expect(object).to have_received(:object_id)
-        end
-      end
-      """
-    When I run `rspec failed_spy_spec.rb`
-    Then the output should contain "that method has not been stubbed"

data/features/step_definitions/additional_cli_steps.rb

@@ -1,11 +0,0 @@
-Then /^the example(?:s)? should(?: all)? pass$/ do
-  step %q{the output should contain "0 failures"}
-  step %q{the exit status should be 0}
-end
-
-# Useful for when the output is slightly different on different versions of ruby
-Then /^the output should contain "([^"]*)" or "([^"]*)"$/ do |string1, string2|
-  unless [string1, string2].any? { |s| all_output =~ regexp(s) }
-    fail %Q{Neither "#{string1}" or "#{string2}" were found in:\n#{all_output}}
-  end
-end

data/features/support/env.rb

@@ -1,22 +0,0 @@
-require 'aruba/cucumber'
-require 'rspec/expectations'
-
-Before do
-  if RUBY_PLATFORM =~ /java/ || defined?(Rubinius)
-    @aruba_timeout_seconds = 60
-  else
-    @aruba_timeout_seconds = 5
-  end
-end
-
-Aruba.configure do |config|
-  config.before_cmd do |cmd|
-    set_env('JRUBY_OPTS', "-X-C #{ENV['JRUBY_OPTS']}") # disable JIT since these processes are so short lived
-  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/support/rubinius.rb

@@ -1,6 +0,0 @@
-# Required until https://github.com/rubinius/rubinius/issues/2430 is resolved
-ENV['RBXOPT'] = "#{ENV["RBXOPT"]} -Xcompiler.no_rbc"
-
-Around "@unsupported-on-rbx" do |scenario, block|
-  block.call unless defined?(Rubinius)
-end

data/features/test_frameworks/test_unit.feature

@@ -1,54 +0,0 @@
-Feature: Test::Unit integration
-
-  rspec-mocks is a stand-alone gem that can be used without the rest of
-  RSpec. If you like the way Test::Unit (or MiniTest) organizes tests, but
-  prefer RSpec's approach to mocking/stubbing/doubles etc, you can have both.
-
-  The one downside is that failures are reported as errors with MiniTest.
-
-  Scenario: use rspec/mocks with Test::Unit
-    Given a file named "rspec_mocks_test.rb" with:
-      """ruby
-      require 'test/unit'
-      require 'rspec/mocks'
-
-      class RSpecMocksTest < Test::Unit::TestCase
-        include RSpec::Mocks::ExampleMethods
-
-        def setup
-          RSpec::Mocks.setup
-        end
-
-        def teardown
-          RSpec::Mocks.verify
-        ensure
-          RSpec::Mocks.teardown
-        end
-
-        def test_passing_positive_expectation
-          obj = Object.new
-          expect(obj).to receive(:message)
-          obj.message
-        end
-
-        def test_failing_positive_expectation
-          obj = Object.new
-          expect(obj).to receive(:message)
-          obj.message
-        end
-
-        def test_passing_negative_expectation
-          obj = Object.new
-          expect(obj).to_not receive(:message)
-        end
-
-        def test_failing_negative_expectation
-          obj = Object.new
-          expect(obj).to_not receive(:message)
-          obj.message
-        end
-      end
-      """
-     When I run `ruby rspec_mocks_test.rb`
-     Then the output should contain "4 tests, 0 assertions, 0 failures, 1 errors" or "4 tests, 0 assertions, 1 failures, 0 errors"
-     And the output should contain "expected: 0 times with any arguments"

data/features/verifying_doubles/README.md

@@ -1,17 +0,0 @@
-## 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 underlying object or class is not defined, but
-when run with it present (either as a full spec run or by explicitly preloading
-collaborators) a failure will be triggered if an invalid method is being
-stubbed or a method is called with an invalid number of arguments.
-
-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.

data/features/verifying_doubles/class_doubles.feature

@@ -1,73 +0,0 @@
-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:"

data/features/verifying_doubles/dynamic_classes.feature

@@ -1,71 +0,0 @@
-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/instance_doubles.feature

@@ -1,103 +0,0 @@
-Feature: Using an instance double
-
-  An `instance_double` is the most common type of verifying double. It takes a
-  class name or object as its first argument, then verifies that any methods
-  being stubbed would be present on an _instance_ of that class. If any
-  argument matchers are specified, it also verifies that the number of
-  arguments is correct.
-
-  For methods handled by `method_missing`, see [dynamic
-  objects](./dynamic-objects).
-
-  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 "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 passes with dependencies loaded and method implemented
-    Given a file named "app/models/console_notifier.rb" with:
-      """ruby
-      class ConsoleNotifier
-        def notify(msg)
-          puts message
-        end
-      end
-      """
-
-    When I run `rspec -r./spec/spec_helper spec/unit/user_spec.rb`
-    Then the examples should all pass
-
-  Scenario: spec fails with dependencies loaded and method unimplemented
-    Given a file named "app/models/console_notifier.rb" with:
-      """ruby
-      class ConsoleNotifier
-      end
-      """
-    When I run `rspec -r./spec/spec_helper spec/unit/user_spec.rb`
-    Then the output should contain "1 example, 1 failure"
-    And the output should contain "ConsoleNotifier does not implement:"
-
-  Scenario: spec fails with dependencies loaded and incorrect arity
-    Given a file named "app/models/console_notifier.rb" with:
-      """ruby
-      class ConsoleNotifier
-        def notify(msg, color)
-          puts color + message
-        end
-      end
-      """
-    When I run `rspec -r./spec/spec_helper spec/unit/user_spec.rb`
-    Then the output should contain "1 example, 1 failure"
-    And the output should contain "Wrong number of arguments."