rspec-mocks 2.13.1 → 2.14.0.rc1

data/features/message_expectations/expect_message.feature

@@ -1,94 +0,0 @@
-Feature: expect a message
-
-  Use should_receive() to set an expectation that a receiver should receive a
-  message before the example is completed.
-
-  Scenario: expect a message
-    Given a file named "spec/account_spec.rb" with:
-      """ruby
-      require "account"
-
-      describe Account do
-        context "when closed" do
-          it "logs an account closed message" do
-            logger = double("logger")
-            account = Account.new
-            account.logger = logger
-
-            logger.should_receive(:account_closed)
-
-            account.close
-          end
-        end
-      end
-      """
-    And a file named "lib/account.rb" with:
-      """ruby
-      class Account
-        attr_accessor :logger
-
-        def close
-          logger.account_closed
-        end
-      end
-      """
-    When I run `rspec spec/account_spec.rb`
-    Then the output should contain "1 example, 0 failures"
-
-  Scenario: expect a message with an argument
-    Given a file named "spec/account_spec.rb" with:
-      """ruby
-      require "account"
-
-      describe Account do
-        context "when closed" do
-          it "logs an account closed message" do
-            logger = double("logger")
-            account = Account.new
-            account.logger = logger
-
-            logger.should_receive(:account_closed).with(account)
-
-            account.close
-          end
-        end
-      end
-      """
-    And a file named "lib/account.rb" with:
-      """ruby
-      class Account
-        attr_accessor :logger
-
-        def close
-          logger.account_closed(self)
-        end
-      end
-      """
-    When I run `rspec spec/account_spec.rb`
-    Then the output should contain "1 example, 0 failures"
-
-  Scenario: provide a return value
-    Given a file named "message_expectation_spec.rb" with:
-      """ruby
-      describe "a message expectation" do
-        context "with a return value" do
-          context "specified in a block" do
-            it "returns the specified value" do
-              receiver = double("receiver")
-              receiver.should_receive(:message) { :return_value }
-              receiver.message.should eq(:return_value)
-            end
-          end
-
-          context "specified with and_return" do
-            it "returns the specified value" do
-              receiver = double("receiver")
-              receiver.should_receive(:message).and_return(:return_value)
-              receiver.message.should eq(:return_value)
-            end
-          end
-        end
-      end
-      """
-    When I run `rspec message_expectation_spec.rb`
-    Then the output should contain "2 examples, 0 failures"

data/lib/rspec/mocks/any_instance.rb

@@ -1,81 +0,0 @@
-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/expectation_chain'
-require 'rspec/mocks/any_instance/message_chains'
-require 'rspec/mocks/any_instance/recorder'
-
-module RSpec
-  module Mocks
-    module AnyInstance
-      # Used to set stubs and message expectations on any instance of a given
-      # class. Returns a [Recorder](Recorder), which records messages like
-      # `stub` and `should_receive` for later playback on instances of the
-      # class.
-      #
-      # @example
-      #
-      #     Car.any_instance.should_receive(:go)
-      #     race = Race.new
-      #     race.cars << Car.new
-      #     race.go # assuming this delegates to all of its cars
-      #             # this example would pass
-      #
-      #     Account.any_instance.stub(:balance) { Money.new(:USD, 25) }
-      #     Account.new.balance # => Money.new(:USD, 25))
-      #
-      # @return [Recorder]
-      def any_instance
-        RSpec::Mocks::space.add(self)
-        modify_dup_to_remove_mock_proxy_when_invoked
-        __recorder
-      end
-
-      # @private
-      def rspec_verify
-        __recorder.verify
-        super
-      ensure
-        __recorder.stop_all_observation!
-        restore_dup
-        @__recorder = nil
-      end
-
-      # @private
-      def rspec_reset
-        restore_dup
-        __mock_proxy.reset
-      end
-
-      # @private
-      def __recorder
-        @__recorder ||= AnyInstance::Recorder.new(self)
-      end
-
-      private
-      def modify_dup_to_remove_mock_proxy_when_invoked
-        if method_defined?(:dup) and !method_defined?(:__rspec_original_dup)
-          class_eval do
-            def __rspec_dup(*arguments, &block)
-              __remove_mock_proxy
-              __rspec_original_dup(*arguments, &block)
-            end
-
-            alias_method  :__rspec_original_dup, :dup
-            alias_method  :dup, :__rspec_dup
-          end
-        end
-      end
-
-      def restore_dup
-        if method_defined?(:__rspec_original_dup)
-          class_eval do
-            alias_method  :dup, :__rspec_original_dup
-            remove_method :__rspec_original_dup
-            remove_method :__rspec_dup
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-if defined?(Psych) && Psych.respond_to?(:dump)
-  module Psych
-    class << self
-      def dump_with_mocks(object, *args)
-        return dump_without_mocks(object, *args) unless object.instance_variable_defined?(:@mock_proxy)
-
-        mp = object.instance_variable_get(:@mock_proxy)
-        return dump_without_mocks(object, *args) unless mp.is_a?(::RSpec::Mocks::Proxy)
-
-        object.__send__(:remove_instance_variable, :@mock_proxy)
-
-        begin
-          dump_without_mocks(object, *args)
-        ensure
-          object.instance_variable_set(:@mock_proxy, mp)
-        end
-      end
-
-      alias_method :dump_without_mocks, :dump
-      alias_method :dump, :dump_with_mocks
-    end
-  end
-end

data/lib/rspec/mocks/methods.rb

@@ -1,155 +0,0 @@
-module RSpec
-  module Mocks
-    # Methods that are added to every object.
-    module Methods
-      # Sets and expectation that this object should receive a message before
-      # the end of the example.
-      #
-      # @example
-      #
-      #     logger = double('logger')
-      #     thing_that_logs = ThingThatLogs.new(logger)
-      #     logger.should_receive(:log)
-      #     thing_that_logs.do_something_that_logs_a_message
-      def should_receive(message, opts={}, &block)
-        __mock_proxy.add_message_expectation(opts[:expected_from] || caller(1)[0], message.to_sym, opts, &block)
-      end
-
-      # Sets and expectation that this object should _not_ receive a message
-      # during this example.
-      def should_not_receive(message, &block)
-        __mock_proxy.add_negative_message_expectation(caller(1)[0], message.to_sym, &block)
-      end
-
-      # Tells the object to respond to the message with the specified value.
-      #
-      # @example
-      #
-      #     counter.stub(:count).and_return(37)
-      #     counter.stub(:count => 37)
-      #     counter.stub(:count) { 37 }
-      def stub(message_or_hash, opts={}, &block)
-        if Hash === message_or_hash
-          message_or_hash.each {|message, value| stub(message).and_return value }
-        else
-          __mock_proxy.add_stub(caller(1)[0], message_or_hash.to_sym, opts, &block)
-        end
-      end
-
-      # Removes a stub. On a double, the object will no longer respond to
-      # `message`. On a real object, the original method (if it exists) is
-      # restored.
-      #
-      # This is rarely used, but can be useful when a stub is set up during a
-      # shared `before` hook for the common case, but you want to replace it
-      # for a special case.
-      def unstub(message)
-        __mock_proxy.remove_stub(message)
-      end
-
-      alias_method :stub!, :stub
-      alias_method :unstub!, :unstub
-
-      # @overload stub_chain(method1, method2)
-      # @overload stub_chain("method1.method2")
-      # @overload stub_chain(method1, method_to_value_hash)
-      #
-      # Stubs a chain of methods.
-      #
-      # ## Warning:
-      #
-      # Chains can be arbitrarily long, which makes it quite painless to
-      # violate the Law of Demeter in violent ways, so you should consider any
-      # use of `stub_chain` a code smell. Even though not all code smells
-      # indicate real problems (think fluent interfaces), `stub_chain` still
-      # results in brittle examples.  For example, if you write
-      # `foo.stub_chain(:bar, :baz => 37)` in a spec and then the
-      # implementation calls `foo.baz.bar`, the stub will not work.
-      #
-      # @example
-      #
-      #     double.stub_chain("foo.bar") { :baz }
-      #     double.stub_chain(:foo, :bar => :baz)
-      #     double.stub_chain(:foo, :bar) { :baz }
-      #
-      #     # Given any of ^^ these three forms ^^:
-      #     double.foo.bar # => :baz
-      #
-      #     # Common use in Rails/ActiveRecord:
-      #     Article.stub_chain("recent.published") { [Article.new] }
-      def stub_chain(*chain, &blk)
-        chain, blk = format_chain(*chain, &blk)
-        if chain.length > 1
-          if matching_stub = __mock_proxy.__send__(:find_matching_method_stub, chain[0].to_sym)
-            chain.shift
-            matching_stub.invoke(nil).stub_chain(*chain, &blk)
-          else
-            next_in_chain = Mock.new
-            stub(chain.shift) { next_in_chain }
-            next_in_chain.stub_chain(*chain, &blk)
-          end
-        else
-          stub(chain.shift, &blk)
-        end
-      end
-
-      # Tells the object to respond to all messages. If specific stub values
-      # are declared, they'll work as expected. If not, the receiver is
-      # returned.
-      def as_null_object
-        @_null_object = true
-        __mock_proxy.as_null_object
-      end
-
-      # Returns true if this object has received `as_null_object`
-      def null_object?
-        defined?(@_null_object)
-      end
-
-      # @private
-      def received_message?(message, *args, &block)
-        __mock_proxy.received_message?(message, *args, &block)
-      end
-
-      # @private
-      def rspec_verify
-        __mock_proxy.verify
-      end
-
-      # @private
-      def rspec_reset
-        __mock_proxy.reset
-      end
-
-    private
-
-      def __mock_proxy
-        @mock_proxy ||= begin
-          mp = if TestDouble === self
-            Proxy.new(self, @name, @options)
-          else
-            Proxy.new(self)
-          end
-
-          Serialization.fix_for(self)
-          mp
-        end
-      end
-      
-      def __remove_mock_proxy
-        @mock_proxy = nil
-      end
-
-      def format_chain(*chain, &blk)
-        if Hash === chain.last
-          hash = chain.pop
-          hash.each do |k,v|
-            chain << k
-            blk = lambda { v }
-          end
-        end
-        return chain.join('.').split('.'), blk
-      end
-    end
-  end
-end

data/lib/rspec/mocks/serialization.rb

@@ -1,34 +0,0 @@
-require 'rspec/mocks/extensions/marshal'
-require 'rspec/mocks/extensions/psych' if defined?(::Psych)
-
-module RSpec
-  module Mocks
-    # @private
-    module Serialization
-      # @private
-      def self.fix_for(object)
-        object.extend(YAML) if defined?(::YAML)
-      rescue TypeError
-        # Can't extend Fixnums, Symbols, true, false, or nil
-      end
-
-      # @private
-      module YAML
-        # @private
-        def to_yaml(options = {})
-          return nil if defined?(::Psych) && options.respond_to?(:[]) && options[:nodump]
-          return super(options) unless instance_variable_defined?(:@mock_proxy)
-
-          mp = @mock_proxy
-          remove_instance_variable(:@mock_proxy)
-
-          begin
-            super(options)
-          ensure
-            @mock_proxy = mp
-          end
-        end
-      end
-    end
-  end
-end

data/spec/rspec/mocks/combining_implementation_instructions_spec.rb

@@ -1,197 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe "Combining implementation instructions" do
-      it 'can combine and_yield and and_return' do
-        dbl = double
-        dbl.stub(:foo).and_yield(5).and_return(3)
-
-        expect { |b|
-          expect(dbl.foo(&b)).to eq(3)
-        }.to yield_with_args(5)
-      end
-
-      describe "combining and_yield, a block implementation and and_return" do
-        def verify_combined_implementation
-          dbl = double
-          (yield dbl).and_yield(5).and_return(3)
-
-          expect { |b|
-            expect(dbl.foo(:arg, &b)).to eq(3)
-          }.to yield_with_args(5)
-
-          expect(@block_called).to be_true
-        end
-
-        it 'works when passing a block to `stub`' do
-          verify_combined_implementation do |dbl|
-            dbl.stub(:foo) { @block_called = true }
-          end
-        end
-
-        it 'works when passing a block to `with`' do
-          verify_combined_implementation do |dbl|
-            dbl.stub(:foo).with(:arg) { @block_called = true }
-          end
-        end
-
-        it 'works when passing a block to `exactly`' do
-          verify_combined_implementation do |dbl|
-            dbl.should_receive(:foo).exactly(:once) { @block_called = true }
-          end
-        end
-
-        it 'works when passing a block to `at_least`' do
-          verify_combined_implementation do |dbl|
-            dbl.should_receive(:foo).at_least(:once) { @block_called = true }
-          end
-        end
-
-        it 'works when passing a block to `at_most`' do
-          verify_combined_implementation do |dbl|
-            dbl.should_receive(:foo).at_most(:once) { @block_called = true }
-          end
-        end
-
-        it 'works when passing a block to `times`' do
-          verify_combined_implementation do |dbl|
-            dbl.should_receive(:foo).exactly(1).times { @block_called = true }
-          end
-        end
-
-        it 'works when passing a block to `any_number_of_times`' do
-          verify_combined_implementation do |dbl|
-            dbl.should_receive(:foo).any_number_of_times { @block_called = true }
-          end
-        end
-
-        it 'works when passing a block to `once`' do
-          verify_combined_implementation do |dbl|
-            dbl.should_receive(:foo).once { @block_called = true }
-          end
-        end
-
-        it 'works when passing a block to `twice`' do
-          the_double = nil
-
-          verify_combined_implementation do |dbl|
-            the_double = dbl
-            dbl.should_receive(:foo).twice { @block_called = true }
-          end
-
-          the_double.foo { |a| } # to ensure it is called twice
-        end
-
-        it 'works when passing a block to `ordered`' do
-          verify_combined_implementation do |dbl|
-            dbl.should_receive(:foo).ordered { @block_called = true }
-          end
-        end
-      end
-
-      it 'can combine and_yield and and_return with a block' do
-        dbl = double
-        dbl.stub(:foo).and_yield(5).and_return { :return }
-
-        expect { |b|
-          expect(dbl.foo(&b)).to eq(:return)
-        }.to yield_with_args(5)
-      end
-
-      it 'can combine and_yield and and_raise' do
-        dbl = double
-        dbl.stub(:foo).and_yield(5).and_raise("boom")
-
-        expect { |b|
-          expect { dbl.foo(&b) }.to raise_error("boom")
-        }.to yield_with_args(5)
-      end
-
-      it 'can combine and_yield, a block implementation and and_raise' do
-        dbl = double
-        block_called = false
-        dbl.stub(:foo) { block_called = true }.and_yield(5).and_raise("boom")
-
-        expect { |b|
-          expect { dbl.foo(&b) }.to raise_error("boom")
-        }.to yield_with_args(5)
-
-        expect(block_called).to be_true
-      end
-
-      it 'can combine and_yield and and_throw' do
-        dbl = double
-        dbl.stub(:foo).and_yield(5).and_throw(:bar)
-
-        expect { |b|
-          expect { dbl.foo(&b) }.to throw_symbol(:bar)
-        }.to yield_with_args(5)
-      end
-
-      it 'can combine and_yield, a block implementation and and_throw' do
-        dbl = double
-        block_called = false
-        dbl.stub(:foo) { block_called = true }.and_yield(5).and_throw(:bar)
-
-        expect { |b|
-          expect { dbl.foo(&b) }.to throw_symbol(:bar)
-        }.to yield_with_args(5)
-
-        expect(block_called).to be_true
-      end
-
-      it 'returns `nil` from all terminal actions to discourage further configuration' do
-        expect(double.stub(:foo).and_return(1)).to be_nil
-        expect(double.stub(:foo).and_raise("boom")).to be_nil
-        expect(double.stub(:foo).and_throw(:foo)).to be_nil
-      end
-
-      it 'allows the terminal action to be overriden' do
-        dbl = double
-        stubbed_double = dbl.stub(:foo)
-
-        stubbed_double.and_return(1)
-        expect(dbl.foo).to eq(1)
-
-        stubbed_double.and_return(3)
-        expect(dbl.foo).to eq(3)
-
-        stubbed_double.and_raise("boom")
-        expect { dbl.foo }.to raise_error("boom")
-
-        stubbed_double.and_throw(:bar)
-        expect { dbl.foo }.to throw_symbol(:bar)
-      end
-
-      it 'allows the inner implementation block to be overriden' do
-        dbl = double
-        stubbed_double = dbl.stub(:foo)
-
-        stubbed_double.with(:arg) { :with_block }
-        expect(dbl.foo(:arg)).to eq(:with_block)
-
-        stubbed_double.at_least(:once) { :at_least_block }
-        expect(dbl.foo(:arg)).to eq(:at_least_block)
-      end
-
-      it 'raises an error if `and_call_original` is followed by any other instructions' do
-        dbl = [1, 2, 3]
-        stubbed = dbl.stub(:size)
-        stubbed.and_call_original
-
-        msg_fragment = /cannot be modified further/
-
-        expect { stubbed.and_yield }.to raise_error(msg_fragment)
-        expect { stubbed.and_return(1) }.to raise_error(msg_fragment)
-        expect { stubbed.and_raise("a") }.to raise_error(msg_fragment)
-        expect { stubbed.and_throw(:bar) }.to raise_error(msg_fragment)
-
-        expect { stubbed.once { } }.to raise_error(msg_fragment)
-
-        expect(dbl.size).to eq(3)
-      end
-    end
-  end
-end
-