rspec-mocks 3.0.0.beta1 → 3.0.0.beta2

checksums.yaml

@@ -1,15 +0,0 @@
----
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    MWQyODY3ZjBkNmUxYWY1ZjFlZWNlM2Q0NjZlY2M1OTEwOTI3N2E1ZQ==
-  data.tar.gz: !binary |-
-    YzI0OGE3YzFmZDQ4MTc5ZmJlODExYjNjNDE5MzMyOGI4ZTE2ZDY2MQ==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    OTA4ZmE4NjJhNDhjYTFmMWU4MmM3OTkzMTk3OTQ3M2YyYTNmMzljYzQzNDFm
-    MjgwMzE0NDlmZDFmYzVkMzIwZWIzOGYxNjZlN2U1MDMwZDIwNGYxZDkzYWFj
-    MDAzM2NmMWEyNDA1NTg5OTBmMzViMzdhYjRlMTUyODNmMDJkMjU=
-  data.tar.gz: !binary |-
-    YjExYjNmYzZhMTAyZjQyN2RjNWY1NmNhMjRiNmU5NDhjOTY0NWNiYzMxOWUy
-    MGMzOGIzOTYzNDhmOWNlNzVkODQ5ZmYyN2RmN2MwZGM2ZThmMWIwY2U3NGIx
-    M2Q3ZTFhNTVkZjFjZmJhNmQ4M2NkNTJhMGRiN2IzMmY3ZThkNGQ=

checksums.yaml.gz.sig

@@ -1,2 +0,0 @@
-}��{ �ͨ�k}���{Z�E	����@;P�?�t���.�+��D.�d����
�p3x|�Vv��hhv�p@�i�R8���E(���¸D~�����~�3�jC1Of+Wm7*��k�
-�3�

data/features/outside_rspec/configuration.feature

@@ -1,60 +0,0 @@
-Feature: configure any test framework to use rspec-mocks
-
-  Test frameworks that want to use rspec-mocks can use
-  RSpec::Mocks::setup(self) to hook into rspec-mocks. Doing so adds the
-  following:
-
-    To the object passed to setup:
-
-      double # creates a test double
-      mock   # creates a test double
-      stub   # creates a test double
-
-    To every object in the system:
-
-      should_receive
-      should_not_receive
-      stub
-
-  NOTICE: the stub() method that is added to the object passed to setup is not
-  the same stub() method that is added to every other object.
-
-  Scenario: RSpec::Mocks::setup(object) adds double, mock, and stub methods to the submitted object
-    Given a file named "foo.rb" with:
-      """ruby
-      require 'rspec/mocks'
-
-      class CodeExample
-        def init
-          RSpec::Mocks::setup(self)
-        end
-      end
-
-      example = CodeExample.new
-      example.init
-
-      puts example.respond_to?(:double)
-      """
-
-    When I run `ruby foo.rb`
-    Then the output should contain "true"
-    But  the output should not contain "false"
-
-  Scenario: RSpec::Mocks::setup(anything) adds methods to Object
-    Given a file named "foo.rb" with:
-      """ruby
-      require 'rspec/mocks'
-
-      RSpec::Mocks::setup(Object.new)
-
-      obj = Object.new
-
-      puts obj.respond_to?(:should_receive)
-      puts obj.respond_to?(:should_not_receive)
-      puts obj.respond_to?(:stub)
-      """
-
-    When I run `ruby foo.rb`
-    Then the output should contain "true"
-    But  the output should not contain "false"
-

data/lib/rspec/mocks/arity_calculator.rb

@@ -1,66 +0,0 @@
-module RSpec
-  module Mocks
-
-    # Figures out the valid arity range for a method. Surprisingly non-trivial.
-    class ArityCalculator
-
-      def initialize(method)
-        @method = method
-      end
-
-      # @api private
-      def within_range?(actual)
-        min_arity <= actual && actual <= max_arity
-      end
-
-      # @api private
-      def range_description
-        return min_arity.to_s if min_arity == max_arity
-        return "#{min_arity} or more" if max_arity == INFINITY
-        "#{min_arity} to #{max_arity}"
-      end
-
-      private
-
-      def method
-        @method
-      end
-
-      # @api private
-      def self.supports_optional_and_splat_args?
-        Method.method_defined?(:parameters)
-      end
-
-      def min_arity
-        return method.arity if method.arity >= 0
-        # `~` inverts the one's complement and gives us the number of
-        # required arguments.
-        ~method.arity
-      end
-
-      if supports_optional_and_splat_args?
-        def max_arity
-          params = method.parameters
-          if params.any? {|(type, _)| type == :rest }
-            # Method takes a splat argument
-            return INFINITY
-          else
-            params.count {|(type, _)| type != :block }
-          end
-        end
-      else
-        def max_arity
-          # On 1.8, Method#parameters does not exist.  There is no way to
-          # distinguish between default and splat args, so there is no way to
-          # have it work correctly for both default and splat args, as far as I
-          # can tell. The best we can do is consider it INFINITY (to be
-          # tolerant of splat args).
-          method.arity < 0 ? INFINITY : method.arity
-        end
-      end
-
-      INFINITY = 1/0.0
-    end
-  end
-end
-

data/lib/rspec/mocks/errors.rb

@@ -1,12 +0,0 @@
-module RSpec
-  module Mocks
-    # @private
-    class MockExpectationError < Exception
-    end
-
-    # @private
-    class AmbiguousReturnError < StandardError
-    end
-  end
-end
-

data/lib/rspec/mocks/mock.rb

@@ -1,7 +0,0 @@
-module RSpec
-  module Mocks
-    class Mock
-      include TestDouble
-    end
-  end
-end

data/lib/rspec/mocks/proxy_for_nil.rb

@@ -1,37 +0,0 @@
-module RSpec
-  module Mocks
-    # @private
-    class ProxyForNil < Proxy
-
-      def initialize(order_group)
-        @warn_about_expectations = true
-        super nil, order_group
-      end
-      attr_accessor :warn_about_expectations
-      alias warn_about_expectations? warn_about_expectations
-
-      def add_message_expectation(location, method_name, opts={}, &block)
-        warn(method_name) if warn_about_expectations?
-        super
-      end
-
-      def add_negative_message_expectation(location, method_name, &implementation)
-        warn(method_name) if warn_about_expectations?
-        super
-      end
-
-      def add_stub(location, method_name, opts={}, &implementation)
-        warn(method_name) if warn_about_expectations?
-        super
-      end
-
-      private
-
-      def warn method_name
-        source = CallerFilter.first_non_rspec_line
-        Kernel.warn("An expectation of :#{method_name} was set on nil. Called from #{source}. Use allow_message_expectations_on_nil to disable warnings.")
-      end
-
-    end
-  end
-end

data/lib/rspec/mocks/stub_chain.rb

@@ -1,51 +0,0 @@
-module RSpec
-  module Mocks
-    # @private
-    class StubChain
-      def self.stub_chain_on(object, *chain, &blk)
-        new(object, *chain, &blk).stub_chain
-      end
-
-      attr_reader :object, :chain, :block
-
-      def initialize(object, *chain, &blk)
-        @object = object
-        @chain, @block = format_chain(*chain, &blk)
-      end
-
-      def stub_chain
-        if chain.length > 1
-          if matching_stub = find_matching_stub
-            chain.shift
-            matching_stub.invoke(nil).stub_chain(*chain, &block)
-          else
-            next_in_chain = Mock.new
-            object.stub(chain.shift) { next_in_chain }
-            StubChain.stub_chain_on(next_in_chain, *chain, &block)
-          end
-        else
-          object.stub(chain.shift, &block)
-        end
-      end
-
-    private
-
-      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
-
-      def find_matching_stub
-        ::RSpec::Mocks.proxy_for(object).
-          __send__(:find_matching_method_stub, chain.first.to_sym)
-      end
-    end
-  end
-end
-

data/spec/rspec/mocks/argument_expectation_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe ArgumentListMatcher do
-      let(:argument_expectation) { RSpec::Mocks::ArgumentListMatcher.new }
-      let(:obj) { double("matcher") }
-
-      it "considers an object that responds to #matches? and #failure_message_for_should to be a matcher" do
-        obj.stub(:matches?)
-        obj.stub(:failure_message_for_should)
-        expect(argument_expectation.send(:is_matcher?, obj)).to be_truthy
-      end
-
-      it "considers an object that responds to #matches? and #failure_message to be a matcher for backward compatibility" do
-        obj.stub(:matches?)
-        obj.stub(:failure_message)
-        expect(argument_expectation.send(:is_matcher?, obj)).to be_truthy
-      end
-
-      it "does NOT consider an object that only responds to #matches? to be a matcher" do
-        obj.stub(:matches?)
-        expect(argument_expectation.send(:is_matcher?, obj)).to be_falsey
-      end
-
-      it "does not consider a null object to be a matcher" do
-        obj.as_null_object
-        expect(argument_expectation.send(:is_matcher?, obj)).to be_falsey
-      end
-    end
-  end
-end

data/spec/rspec/mocks/arity_calculator_spec.rb

@@ -1,95 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe ArityCalculator do
-      describe '#verify!' do
-        subject { described_class.new(test_method) }
-
-        def within_range?(arity)
-          subject.within_range?(arity)
-        end
-
-        def description
-          subject.range_description
-        end
-
-        describe 'with a method with arguments' do
-          def arity_two(x, y); end
-
-          let(:test_method) { method(:arity_two) }
-
-          it 'covers only the exact arity' do
-            expect(within_range?(1)).to eq(false)
-            expect(within_range?(2)).to eq(true)
-            expect(within_range?(3)).to eq(false)
-          end
-
-          it 'is described precisely' do
-            expect(description).to eq("2")
-          end
-        end
-
-        describe 'a method with splat arguments' do
-          def arity_splat(_, *); end
-
-          let(:test_method) { method(:arity_splat) }
-
-          it 'covers a range from the lower bound upwards' do
-            expect(within_range?(0)).to eq(false)
-            expect(within_range?(1)).to eq(true)
-            expect(within_range?(2)).to eq(true)
-            expect(within_range?(3)).to eq(true)
-          end
-
-          it 'is described with no upper bound' do
-            expect(description).to eq("1 or more")
-          end
-        end
-
-        describe 'a method with optional arguments' do
-          def arity_optional(x, y, z = 1); end
-
-          let(:test_method) { method(:arity_optional) }
-
-          it 'covers a range from min to max possible arguments' do
-            expect(within_range?(1)).to eq(false)
-            expect(within_range?(2)).to eq(true)
-            expect(within_range?(3)).to eq(true)
-
-            if ArityCalculator.supports_optional_and_splat_args?
-              expect(within_range?(4)).to eq(false)
-            else
-              expect(within_range?(4)).to eq(true)
-            end
-          end
-
-          if ArityCalculator.supports_optional_and_splat_args?
-            it 'is described as a range' do
-              expect(description).to eq("2 to 3")
-            end
-          else
-            it 'is described with no upper bound' do
-              expect(description).to eq("2 or more")
-            end
-          end
-        end
-
-        describe 'a method with a block' do
-          def arity_block(_, &block); end
-
-          let(:test_method) { method(:arity_block) }
-
-          it 'does not count the block as a parameter' do
-            expect(within_range?(1)).to eq(true)
-            expect(within_range?(2)).to eq(false)
-          end
-
-          it 'is described precisely' do
-            expect(description).to eq("1")
-          end
-        end
-      end
-    end
-  end
-end

data/spec/rspec/mocks/mock_space_spec.rb

@@ -1,113 +0,0 @@
-require 'spec_helper'
-require 'rspec/mocks'
-
-module RSpec
-  module Mocks
-    describe Space do
-      let(:space) { RSpec::Mocks::Space.new }
-      let(:dbl_1) { Object.new }
-      let(:dbl_2) { Object.new }
-
-      before do
-        space.ensure_registered(dbl_1)
-        space.ensure_registered(dbl_2)
-      end
-
-      it "verifies all mocks within" do
-        verifies = []
-
-        space.proxy_for(dbl_1).stub(:verify) { verifies << :dbl_1 }
-        space.proxy_for(dbl_2).stub(:verify) { verifies << :dbl_2 }
-
-        space.verify_all
-
-        expect(verifies).to match_array([:dbl_1, :dbl_2])
-      end
-
-      def define_singleton_method_on_recorder_for(klass, name, &block)
-        recorder = space.any_instance_recorder_for(klass)
-        (class << recorder; self; end).send(:define_method, name, &block)
-      end
-
-      it 'verifies all any_instance recorders within' do
-        klass_1, klass_2 = Class.new, Class.new
-
-        verifies = []
-
-        # We can't `stub` a method on the recorder because it defines its own `stub`...
-        define_singleton_method_on_recorder_for(klass_1, :verify) { verifies << :klass_1 }
-        define_singleton_method_on_recorder_for(klass_2, :verify) { verifies << :klass_2 }
-
-        space.verify_all
-
-        expect(verifies).to match_array([:klass_1, :klass_2])
-      end
-
-      it "resets all mocks within" do
-        resets = []
-
-        space.proxy_for(dbl_1).stub(:reset) { resets << :dbl_1 }
-        space.proxy_for(dbl_2).stub(:reset) { resets << :dbl_2 }
-
-        space.reset_all
-
-        expect(resets).to match_array([:dbl_1, :dbl_2])
-      end
-
-      it "does not leak mock proxies between examples" do
-        expect {
-          space.reset_all
-        }.to change { space.proxies.size }.to(0)
-      end
-
-      it 'does not leak any instance recorders between examples' do
-        space.any_instance_recorder_for(Class.new)
-        expect {
-          space.reset_all
-        }.to change { space.any_instance_recorders.size }.to(0)
-      end
-
-      it "resets the ordering" do
-        space.expectation_ordering.register :some_expectation
-
-        expect {
-          space.reset_all
-        }.to change { space.expectation_ordering.empty? }.from(false).to(true)
-      end
-
-      it "only adds an instance once" do
-        m1 = double("mock1")
-
-        expect {
-          space.ensure_registered(m1)
-        }.to change { space.proxies }
-
-        expect {
-          space.ensure_registered(m1)
-        }.not_to change { space.proxies }
-      end
-
-      it 'returns a consistent any_instance_recorder for a given class' do
-        klass_1, klass_2 = Class.new, Class.new
-
-        r1 = space.any_instance_recorder_for(klass_1)
-        r2 = space.any_instance_recorder_for(klass_1)
-        r3 = space.any_instance_recorder_for(klass_2)
-
-        expect(r1).to be(r2)
-        expect(r1).not_to be(r3)
-      end
-
-      it 'removes an any_instance_recorder when requested' do
-        klass = Class.new
-
-        space.any_instance_recorder_for(klass)
-
-        expect {
-          space.remove_any_instance_recorder_for(klass)
-        }.to change { space.any_instance_recorders.size }.by(-1)
-      end
-    end
-  end
-end
-