rspec-mocks 3.0.0.beta2 → 3.0.0.rc1

data/features/verifying_doubles/object_doubles.feature

@@ -1,65 +0,0 @@
-Feature: Using an object double
-
-  `object_double` can be used to create a double from an existing "template"
-  object, from which it verifies that any stubbed methods on the double also
-  exist on the template. This is useful for objects that are readily
-  constructable, but may have far-reaching side-effects such as talking to a
-  database or external API. In this case, using a double rather than the real
-  thing allows you to focus on the communication patterns of the object's
-  interface without having to worry about accidentally causing side-effects.
-  Object doubles can also be used to verify methods defined on an object using
-  `method_missing`, which is not possible with `instance_double`.
-
-  In addition, `object_double` can be used with specific constant values, as
-  shown below. This is for niche situations, such as when dealing with
-  singleton objects.
-
-  Scenario: doubling an existing object
-    Given a file named "spec/user_spec.rb" with:
-      """ruby
-      class User
-        # Don't want to accidentally trigger this!
-        def save; sleep 100; end
-      end
-
-      def save_user(user)
-        "saved!" if user.save
-      end
-
-      describe '#save_user' do
-        it 'renders message on success' do
-          user = object_double(User.new, :save => true)
-          expect(save_user(user)).to eq("saved!")
-        end
-      end
-      """
-    When I run `rspec spec/user_spec.rb`
-    Then the examples should all pass
-
-
-  Scenario: doubling a constant object
-    Given a file named "spec/email_spec.rb" with:
-      """ruby
-      require 'logger'
-
-      module MyApp
-        LOGGER = Logger.new("myapp")
-      end
-
-      class Email
-        def self.send_to(recipient)
-          MyApp::LOGGER.info("Sent to #{recipient}")
-          # other emailing logic
-        end
-      end
-
-      describe Email do
-        it 'logs a message when sending' do
-          logger = object_double("MyApp::LOGGER", :info => nil).as_stubbed_const
-          Email.send_to('hello@foo.com')
-          expect(logger).to have_received(:info).with("Sent to hello@foo.com")
-        end
-      end
-      """
-    When I run `rspec spec/email_spec.rb`
-    Then the examples should all pass

data/features/verifying_doubles/partial_doubles.feature

@@ -1,34 +0,0 @@
-Feature: Partial doubles
-
-  When the `verify_partial_doubles` configuration option is set, the same argument
-  and method existence checks that are performed for `object_double` are also
-  performed on partial doubles. You should set this unless you have a good
-  reason not to. It defaults to off only for backwards compatibility.
-
-  Scenario: doubling an existing object
-    Given a file named "spec/user_spec.rb" with:
-      """ruby
-      class User
-        def save; false; end
-      end
-
-      def save_user(user)
-        "saved!" if user.save
-      end
-
-      RSpec.configure do |config|
-        config.mock_with :rspec do |mocks|
-          mocks.verify_partial_doubles = true
-        end
-      end
-
-      describe '#save_user' do
-        it 'renders message on success' do
-          user = User.new
-          expect(user).to receive(:saave).and_return(true) # Typo in name
-          expect(save_user(user)).to eq("saved!")
-        end
-      end
-      """
-    When I run `rspec spec/user_spec.rb`
-    Then the output should contain "1 example, 1 failure"

data/lib/rspec/mocks/extensions/marshal.rb

@@ -1,17 +0,0 @@
-module Marshal
-  class << self
-    # Duplicates any mock objects before serialization. Otherwise,
-    # serialization will fail because methods exist on the singleton class.
-    def dump_with_mocks(object, *rest)
-      if !::RSpec::Mocks.space.registered?(object) || NilClass === object
-        dump_without_mocks(object, *rest)
-      else
-        dump_without_mocks(object.dup, *rest)
-      end
-    end
-
-    alias_method :dump_without_mocks, :dump
-    undef_method :dump
-    alias_method :dump, :dump_with_mocks
-  end
-end

data/lib/rspec/mocks/framework.rb

@@ -1,35 +0,0 @@
-# Require everything except the global extensions of class and object. This
-# supports wrapping rspec's mocking functionality without invading every
-# object in the system.
-
-require 'rspec/support/caller_filter'
-require 'rspec/support/warnings'
-require 'rspec/mocks/instance_method_stasher'
-require 'rspec/mocks/method_double'
-require 'rspec/mocks/argument_matchers'
-require 'rspec/mocks/example_methods'
-require 'rspec/mocks/proxy'
-require 'rspec/mocks/test_double'
-require 'rspec/mocks/argument_list_matcher'
-require 'rspec/mocks/message_expectation'
-require 'rspec/mocks/order_group'
-require 'rspec/mocks/error_generator'
-require 'rspec/mocks/space'
-require 'rspec/mocks/extensions/marshal'
-require 'rspec/mocks/any_instance/chain'
-require 'rspec/mocks/any_instance/stub_chain'
-require 'rspec/mocks/any_instance/stub_chain_chain'
-require 'rspec/mocks/any_instance/expect_chain_chain'
-require 'rspec/mocks/any_instance/expectation_chain'
-require 'rspec/mocks/any_instance/message_chains'
-require 'rspec/mocks/any_instance/recorder'
-require 'rspec/mocks/mutate_const'
-require 'rspec/mocks/matchers/have_received'
-require 'rspec/mocks/matchers/receive'
-require 'rspec/mocks/matchers/receive_messages'
-require 'rspec/mocks/matchers/receive_message_chain'
-require 'rspec/mocks/message_chain'
-require 'rspec/mocks/targets'
-require 'rspec/mocks/syntax'
-require 'rspec/mocks/configuration'
-require 'rspec/mocks/verifying_double'

data/lib/rspec/mocks/method_signature_verifier.rb

@@ -1,207 +0,0 @@
-require 'rspec/mocks/ruby_features'
-
-module RSpec
-  module Mocks
-    # Extracts info about the number of arguments and allowed/required
-    # keyword args of a given method.
-    #
-    # @api private
-    class MethodSignature
-      attr_reader :min_non_kw_args, :max_non_kw_args
-
-      def initialize(method)
-        @method = method
-        classify_parameters
-      end
-
-      def non_kw_args_arity_description
-        case max_non_kw_args
-          when min_non_kw_args then min_non_kw_args.to_s
-          when INFINITY then "#{min_non_kw_args} or more"
-          else "#{min_non_kw_args} to #{max_non_kw_args}"
-        end
-      end
-
-      if RubyFeatures.optional_and_splat_args_supported?
-        def description
-          @description ||= begin
-            parts = []
-
-            unless non_kw_args_arity_description == "0"
-              parts << "arity of #{non_kw_args_arity_description}"
-            end
-
-            if @optional_kw_args.any?
-              parts << "optional keyword args (#{@optional_kw_args.map(&:inspect).join(", ")})"
-            end
-
-            if @required_kw_args.any?
-              parts << "required keyword args (#{@required_kw_args.map(&:inspect).join(", ")})"
-            end
-
-            if @allows_any_kw_args
-              parts << "any additional keyword args"
-            end
-
-            parts.join(" and ")
-          end
-        end
-
-        def missing_kw_args_from(given_kw_args)
-          @required_kw_args - given_kw_args
-        end
-
-        def invalid_kw_args_from(given_kw_args)
-          return [] if @allows_any_kw_args
-          given_kw_args - @allowed_kw_args
-        end
-
-        def has_kw_args_in?(args)
-          return false unless Hash === args.last
-          return false if args.count <= min_non_kw_args
-
-          @allows_any_kw_args || @allowed_kw_args.any?
-        end
-
-        def classify_parameters
-          optional_non_kw_args = @min_non_kw_args = 0
-          @optional_kw_args, @required_kw_args = [], []
-          @allows_any_kw_args = false
-
-          @method.parameters.each do |(type, name)|
-            case type
-              # def foo(a:)
-              when :keyreq  then @required_kw_args << name
-              # def foo(a: 1)
-              when :key     then @optional_kw_args << name
-              # def foo(**kw_args)
-              when :keyrest then @allows_any_kw_args = true
-              # def foo(a)
-              when :req     then @min_non_kw_args += 1
-              # def foo(a = 1)
-              when :opt     then optional_non_kw_args += 1
-              # def foo(*a)
-              when :rest    then optional_non_kw_args = INFINITY
-            end
-          end
-
-          @max_non_kw_args = @min_non_kw_args  + optional_non_kw_args
-          @allowed_kw_args = @required_kw_args + @optional_kw_args
-        end
-      else
-        def description
-          "arity of #{non_kw_args_arity_description}"
-        end
-
-        def missing_kw_args_from(given_kw_args)
-          []
-        end
-
-        def invalid_kw_args_from(given_kw_args)
-          []
-        end
-
-        def has_kw_args_in?(args)
-          false
-        end
-
-        def classify_parameters
-          arity = @method.arity
-          if arity < 0
-            # `~` inverts the one's complement and gives us the
-            # number of required args
-            @min_non_kw_args = ~arity
-            @max_non_kw_args = INFINITY
-          else
-            @min_non_kw_args = arity
-            @max_non_kw_args = arity
-          end
-        end
-      end
-
-      INFINITY = 1/0.0
-    end
-
-    # Deals with the slightly different semantics of block arguments.
-    # For methods, arguments are required unless a default value is provided.
-    # For blocks, arguments are optional, even if no default value is provided.
-    #
-    # However, we want to treat block args as required since you virtually always
-    # want to pass a value for each received argument and our `and_yield` has
-    # treated block args as required for many years.
-    #
-    # @api private
-    class BlockSignature < MethodSignature
-      if RubyFeatures.optional_and_splat_args_supported?
-        def classify_parameters
-          super
-          @min_non_kw_args = @max_non_kw_args unless @max_non_kw_args == INFINITY
-        end
-      end
-    end
-
-    # Figures out wheter a given method can accept various arguments.
-    # Surprisingly non-trivial.
-    #
-    # @api private
-    class MethodSignatureVerifier
-      # @api private
-      attr_reader :non_kw_args, :kw_args
-
-      def initialize(signature, args)
-        @signature = signature
-        @non_kw_args, @kw_args = split_args(*args)
-      end
-
-      # @api private
-      def valid?
-         missing_kw_args.empty? &&
-          invalid_kw_args.empty? &&
-          valid_non_kw_args?
-      end
-
-      # @api private
-      def error_message
-        if missing_kw_args.any?
-          "Missing required keyword arguments: %s" % [
-            missing_kw_args.join(", ")
-          ]
-        elsif invalid_kw_args.any?
-          "Invalid keyword arguments provided: %s" % [
-            invalid_kw_args.join(", ")
-          ]
-        elsif !valid_non_kw_args?
-          "Wrong number of arguments. Expected %s, got %s." % [
-            @signature.non_kw_args_arity_description,
-            non_kw_args.length
-          ]
-        end
-      end
-
-    private
-
-      def valid_non_kw_args?
-        actual = non_kw_args.length
-        @signature.min_non_kw_args <= actual && actual <= @signature.max_non_kw_args
-      end
-
-      def missing_kw_args
-        @signature.missing_kw_args_from(kw_args)
-      end
-
-      def invalid_kw_args
-        @signature.invalid_kw_args_from(kw_args)
-      end
-
-      def split_args(*args)
-        kw_args = if @signature.has_kw_args_in?(args)
-          args.pop.keys
-        else
-          []
-        end
-
-        [args, kw_args]
-      end
-    end
-  end
-end

data/lib/rspec/mocks/ruby_features.rb

@@ -1,24 +0,0 @@
-module RSpec
-  module Mocks
-    # @api private
-    #
-    # Provides query methods for ruby features that differ among
-    # implementations.
-    module RubyFeatures
-      def optional_and_splat_args_supported?
-        Method.method_defined?(:parameters)
-      end
-      module_function :optional_and_splat_args_supported?
-
-      def kw_args_supported?
-        RUBY_VERSION >= '2.0.0' && RUBY_ENGINE != 'rbx'
-      end
-      module_function :kw_args_supported?
-
-      def required_kw_args_supported?
-        RUBY_VERSION >= '2.1.0' && RUBY_ENGINE != 'rbx'
-      end
-      module_function :required_kw_args_supported?
-    end
-  end
-end

data/spec/rspec/mocks/and_call_original_spec.rb

@@ -1,268 +0,0 @@
-require 'spec_helper'
-require 'delegate'
-
-describe "and_call_original" do
-  context "on a partial double" do
-    let(:klass) do
-      Class.new do
-        def meth_1
-          :original
-        end
-
-        def meth_2(x)
-          yield x, :additional_yielded_arg
-        end
-
-        def self.new_instance
-          new
-        end
-      end
-    end
-
-    let(:instance) { klass.new }
-
-    context "when a method that exists has been stubbed previously" do
-      before { allow(instance).to receive(:meth_1).and_return(:override) }
-
-      it 'restores the original behavior' do
-        expect {
-          allow(instance).to receive(:meth_1).and_call_original
-        }.to change(instance, :meth_1).from(:override).to(:original)
-      end
-    end
-
-    context "when a non-existant method has been stubbed previously" do
-      it 'restores the original NameError behavior' do
-        expect { instance.abcd }.to raise_error(NameError).with_message(/abcd/)
-
-        allow(instance).to receive(:abcd).and_return(:override)
-        expect(instance.abcd).to eq(:override)
-
-        allow(instance).to receive(:abcd).and_call_original
-        expect { instance.abcd }.to raise_error(NameError).with_message(/abcd/)
-      end
-    end
-
-    it 'passes the received message through to the original method' do
-      expect(instance).to receive(:meth_1).and_call_original
-      expect(instance.meth_1).to eq(:original)
-    end
-
-    it 'ignores prior declared stubs' do
-      instance.stub(:meth_1).and_return(:stubbed_value)
-      instance.should_receive(:meth_1).and_call_original
-      expect(instance.meth_1).to eq(:original)
-    end
-
-    it 'passes args and blocks through to the original method' do
-      expect(instance).to receive(:meth_2).and_call_original
-      value = instance.meth_2(:submitted_arg) { |a, b| [a, b] }
-      expect(value).to eq([:submitted_arg, :additional_yielded_arg])
-    end
-
-    it 'errors when you pass through the wrong number of args' do
-      expect(instance).to receive(:meth_1).and_call_original
-      expect(instance).to receive(:meth_2).twice.and_call_original
-      expect { instance.meth_1 :a }.to raise_error ArgumentError
-      expect { instance.meth_2 {} }.to raise_error ArgumentError
-      expect { instance.meth_2(:a, :b) {}  }.to raise_error ArgumentError
-    end
-
-    it 'warns when you override an existing implementation' do
-      expect(RSpec).to receive(:warning).with(/overriding a previous stub implementation of `meth_1`.*#{__FILE__}:#{__LINE__ + 1}/)
-      expect(instance).to receive(:meth_1) { true }.and_call_original
-      instance.meth_1
-    end
-
-    context "for singleton methods" do
-      it 'works' do
-        def instance.foo; :bar; end
-        instance.should_receive(:foo).and_call_original
-        expect(instance.foo).to eq(:bar)
-      end
-
-      it 'works for SimpleDelegator subclasses', :if => (RUBY_VERSION.to_f > 1.8) do
-        instance = Class.new(SimpleDelegator).new(1)
-        def instance.foo; :bar; end
-        instance.should_receive(:foo).and_call_original
-        expect(instance.foo).to eq(:bar)
-      end
-    end
-
-    it 'works for methods added through an extended module' do
-      instance.extend Module.new { def foo; :bar; end }
-      instance.should_receive(:foo).and_call_original
-      expect(instance.foo).to eq(:bar)
-    end
-
-    it "works for method added through an extended module onto a class's ancestor" do
-      sub_sub_klass = Class.new(Class.new(klass))
-      klass.extend Module.new { def foo; :bar; end }
-      sub_sub_klass.should_receive(:foo).and_call_original
-      expect(sub_sub_klass.foo).to eq(:bar)
-    end
-
-    it "finds the method on the most direct ancestor even if the method " +
-       "is available on more distant ancestors" do
-      klass.extend Module.new { def foo; :klass_bar; end }
-      sub_klass = Class.new(klass)
-      sub_klass.extend Module.new { def foo; :sub_klass_bar; end }
-      sub_klass.should_receive(:foo).and_call_original
-      expect(sub_klass.foo).to eq(:sub_klass_bar)
-    end
-
-    it "finds the method on the most direct singleton class ancestors even if the method " +
-       "is available on more distant ancestors" do
-      klass.extend Module.new { def foo; :klass_bar; end }
-      sub_klass = Class.new(klass) { def self.foo; :sub_klass_bar; end }
-      sub_sub_klass = Class.new(sub_klass)
-      sub_sub_klass.should_receive(:foo).and_call_original
-      expect(sub_sub_klass.foo).to eq(:sub_klass_bar)
-    end
-
-    context 'when using any_instance' do
-      it 'works for instance methods defined on the class' do
-        klass.any_instance.should_receive(:meth_1).and_call_original
-        expect(klass.new.meth_1).to eq(:original)
-      end
-
-      it 'works for instance methods defined on the superclass of the class' do
-        subclass = Class.new(klass)
-        subclass.any_instance.should_receive(:meth_1).and_call_original
-        expect(subclass.new.meth_1).to eq(:original)
-      end
-
-      it 'works when mocking the method on one class and calling the method on an instance of a subclass' do
-        klass.any_instance.should_receive(:meth_1).and_call_original
-        expect(Class.new(klass).new.meth_1).to eq(:original)
-      end
-    end
-
-    it 'works for class methods defined on a superclass' do
-      subclass = Class.new(klass)
-      subclass.should_receive(:new_instance).and_call_original
-      expect(subclass.new_instance).to be_a(subclass)
-    end
-
-    it 'works for class methods defined on a grandparent class' do
-      sub_subclass = Class.new(Class.new(klass))
-      sub_subclass.should_receive(:new_instance).and_call_original
-      expect(sub_subclass.new_instance).to be_a(sub_subclass)
-    end
-
-    it 'works for class methods defined on the Class class' do
-      klass.should_receive(:new).and_call_original
-      expect(klass.new).to be_an_instance_of(klass)
-    end
-
-    it "works for instance methods defined on the object's class's superclass" do
-      subclass = Class.new(klass)
-      inst = subclass.new
-      inst.should_receive(:meth_1).and_call_original
-      expect(inst.meth_1).to eq(:original)
-    end
-
-    it 'works for aliased methods' do
-      klass = Class.new do
-        class << self
-          alias alternate_new new
-        end
-      end
-
-      klass.should_receive(:alternate_new).and_call_original
-      expect(klass.alternate_new).to be_an_instance_of(klass)
-    end
-
-    context 'on an object that defines method_missing' do
-      before do
-        klass.class_exec do
-          private
-
-          def method_missing(name, *args)
-            if name.to_s == "greet_jack"
-              "Hello, jack"
-            else
-              super
-            end
-          end
-        end
-      end
-
-      it 'works when the method_missing definition handles the message' do
-        instance.should_receive(:greet_jack).and_call_original
-        expect(instance.greet_jack).to eq("Hello, jack")
-      end
-
-      it 'works for an any_instance partial mock' do
-        klass.any_instance.should_receive(:greet_jack).and_call_original
-        expect(instance.greet_jack).to eq("Hello, jack")
-      end
-
-      it 'raises an error for an unhandled message for an any_instance partial mock' do
-        klass.any_instance.should_receive(:not_a_handled_message).and_call_original
-        expect {
-          instance.not_a_handled_message
-        }.to raise_error(NameError, /not_a_handled_message/)
-      end
-
-      it 'raises an error on invocation if method_missing does not handle the message' do
-        instance.should_receive(:not_a_handled_message).and_call_original
-
-        # Note: it should raise a NoMethodError (and usually does), but
-        # due to a weird rspec-expectations issue (see #183) it sometimes
-        # raises a `NameError` when a `be_xxx` predicate matcher has been
-        # recently used. `NameError` is the superclass of `NoMethodError`
-        # so this example will pass regardless.
-        # If/when we solve the rspec-expectations issue, this can (and should)
-        # be changed to `NoMethodError`.
-        expect {
-          instance.not_a_handled_message
-        }.to raise_error(NameError, /not_a_handled_message/)
-      end
-    end
-  end
-
-  context "on a partial double that overrides #method" do
-    let(:request_klass) do
-      Struct.new(:method, :url) do
-        def perform
-          :the_response
-        end
-
-        def self.method
-          :some_method
-        end
-      end
-    end
-
-    let(:request) { request_klass.new(:get, "http://foo.com/bar") }
-
-    it 'still works even though #method has been overriden' do
-      request.should_receive(:perform).and_call_original
-      expect(request.perform).to eq(:the_response)
-    end
-
-    it 'works for a singleton method' do
-      def request.perform
-        :a_response
-      end
-
-      request.should_receive(:perform).and_call_original
-      expect(request.perform).to eq(:a_response)
-    end
-  end
-
-  context "on a pure test double" do
-    let(:instance) { double }
-
-    it 'raises an error even if the double object responds to the message' do
-      expect(instance.to_s).to be_a(String)
-      mock_expectation = instance.should_receive(:to_s)
-      instance.to_s # to satisfy the expectation
-
-      expect {
-        mock_expectation.and_call_original
-      }.to raise_error(/pure test double.*and_call_original.*partial double/i)
-    end
-  end
-end