rspec-mocks 2.99.4 → 3.0.0.beta1

metadata.gz.sig

@@ -0,0 +1 @@
+���

data/features/message_expectations/expect_any_instance_of.feature

@@ -1,27 +0,0 @@
-Feature: expect a message on any instance of a class
-
-  Use `expect_any_instance_of(Class).to receive` to set an expectation that one
-  (and only one) instance of a class receives a message before the example is
-  completed. The spec will fail if no instance receives a message.
-
-  Scenario: expect a message on any instance of a class
-    Given a file named "example_spec.rb" with:
-      """ruby
-      describe "expect_any_instance_of" do
-        before do
-          expect_any_instance_of(Object).to receive(:foo).and_return(:return_value)
-        end
-
-        it "verifies that one instance of the class receives the message" do
-          o = Object.new
-          expect(o.foo).to eq(:return_value)
-        end
-
-        it "fails unless an instance receives that message" do
-          o = Object.new
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the output should contain "2 examples, 1 failure"
-    And the output should contain "1) expect_any_instance_of fails unless an instance receives that message"

data/lib/rspec/mocks/caller_filter.rb

@@ -1,60 +0,0 @@
-module RSpec
-  # Consistent implementation for "cleaning" the caller method to strip out
-  # non-rspec lines. This enables errors to be reported at the call site in
-  # the code using the library, which is far more useful than the particular
-  # internal method that raised an error.
-
-  unless defined?(CallerFilter)
-
-    class CallerFilter
-
-      RSPEC_LIBS = %w[
-        core
-        mocks
-        expectations
-        matchers
-        rails
-      ]
-
-      ADDITIONAL_TOP_LEVEL_FILES = %w[ autorun ]
-
-      LIB_REGEX = %r{/lib/rspec/(#{(RSPEC_LIBS + ADDITIONAL_TOP_LEVEL_FILES).join('|')})(\.rb|/)}
-
-      if RUBY_VERSION >= '2.0.0'
-        def self.first_non_rspec_line
-          # `caller` is an expensive method that scales linearly with the size of
-          # the stack. The performance hit for fetching it in chunks is small,
-          # and since the target line is probably near the top of the stack, the
-          # overall improvement of a chunked search like this is significant.
-          #
-          # See benchmarks/caller.rb for measurements.
-
-          # Initial value here is mostly arbitrary, but is chosen to give good
-          # performance on the common case of creating a double.
-          increment = 5
-          i         = 1
-          line      = nil
-
-          while !line
-            stack = caller(i, increment)
-            return nil unless stack
-
-            line = stack.find { |l| l !~ LIB_REGEX }
-
-            i         += increment
-            increment *= 2 # The choice of two here is arbitrary.
-          end
-
-          line
-        end
-      else
-        # Earlier rubies do not support the two argument form of `caller`. This
-        # fallback is logically the same, but slower.
-        def self.first_non_rspec_line
-          caller.find { |line| line !~ LIB_REGEX }
-        end
-      end
-    end
-
-  end
-end

data/lib/rspec/mocks/deprecation.rb

@@ -1,26 +0,0 @@
-module RSpec
-  module Mocks
-    module Deprecation
-      # @private
-      #
-      # Used internally to print deprecation warnings
-      def deprecate(deprecated, options={})
-        message = "DEPRECATION: #{deprecated} is deprecated."
-        message << " Use #{options[:replacement]} instead." if options[:replacement]
-        message << " Called from #{CallerFilter.first_non_rspec_line}."
-        warn message
-      end
-
-      # @private
-      #
-      # Used internally to print deprecation warnings
-      def warn_deprecation(warning)
-        message = "\nDEPRECATION: #{warning}\n"
-        warn message
-      end
-    end
-  end
-
-  extend(Mocks::Deprecation) unless respond_to?(:deprecate)
-end
-

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

@@ -1,34 +0,0 @@
-module RSpec
-  module Mocks
-    # @private
-    module InstanceExec
-      unless respond_to?(:instance_exec)
-        # @private
-        #
-        # based on Bounded Spec InstanceExec (Mauricio Fernandez)
-        # http://eigenclass.org/hiki/bounded+space+instance_exec
-        # - uses singleton_class of matcher instead of global
-        #   InstanceExecHelper module
-        # - this keeps it scoped to this class only, which is the
-        #   only place we need it
-        # - only necessary for ruby 1.8.6
-        def instance_exec(*args, &block)
-          singleton_class = (class << self; self; end)
-          begin
-            orig_critical, Thread.critical = Thread.critical, true
-            n = 0
-            n += 1 while respond_to?(method_name="__instance_exec#{n}")
-            singleton_class.module_eval{ define_method(method_name, &block) }
-          ensure
-            Thread.critical = orig_critical
-          end
-          begin
-            return send(method_name, *args)
-          ensure
-            singleton_class.module_eval{ remove_method(method_name) } rescue nil
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,63 +0,0 @@
-unless Proc.method_defined? :lambda?
-  module Backports
-    def self.alias_method_chain(mod, target, feature)
-      mod.class_eval do
-        # Strip out punctuation on predicates or bang methods since
-        # e.g. target?_without_feature is not a valid method name.
-        aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
-        yield(aliased_target, punctuation) if block_given?
-
-        with_method, without_method = "#{aliased_target}_with_#{feature}#{punctuation}", "#{aliased_target}_without_#{feature}#{punctuation}"
-
-        alias_method without_method, target
-        alias_method target, with_method
-
-        case
-          when public_method_defined?(without_method)
-            public target
-          when protected_method_defined?(without_method)
-            protected target
-          when private_method_defined?(without_method)
-            private target
-        end
-      end
-    end
-  end
-
-  class Proc
-    # Standard in Ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Proc.html]
-    def lambda?
-      !!__is_lambda__
-    end
-
-    attr_accessor :__is_lambda__
-    private :__is_lambda__
-    private :__is_lambda__=
-  end
-
-  class Method
-    def to_proc_with_lambda_tracking
-      proc = to_proc_without_lambda_tracking
-      proc.send :__is_lambda__=, true
-      proc
-    end
-    Backports.alias_method_chain self, :to_proc, :lambda_tracking
-  end
-
-  module Kernel
-    def lambda_with_lambda_tracking(&block)
-      l = lambda_without_lambda_tracking(&block)
-      l.send :__is_lambda__=, true unless block.send(:__is_lambda__) == false
-      l
-    end
-
-    def proc_with_lambda_tracking(&block)
-      l = proc_without_lambda_tracking(&block)
-      l.send :__is_lambda__=, block.send(:__is_lambda__) == true
-      l
-    end
-
-    Backports.alias_method_chain self, :lambda, :lambda_tracking
-    Backports.alias_method_chain self, :proc, :lambda_tracking
-  end
-end

data/lib/spec/mocks.rb

@@ -1,4 +0,0 @@
-# For backward compatibility with rspec-1
-require 'rspec/mocks'
-
-RSpec.deprecate "require 'spec/mocks'", :replacement => "require 'rspec/mocks'"

data/spec/rspec/mocks/and_return_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe 'and_return' do
-      let(:obj) { double('obj') }
-
-      context 'when no argument is passed' do
-        it 'warns of deprection' do
-          expect_warn_deprecation_with_call_site(__FILE__, __LINE__ + 1, '`and_return` without arguments')
-          obj.stub(:foo).and_return
-          expect(obj.foo).to be_nil
-        end
-      end
-    end
-  end
-end

data/spec/rspec/mocks/any_number_of_times_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-describe "AnyNumberOfTimes" do
-  before(:each) do
-    @mock = RSpec::Mocks::Double.new("test mock")
-    allow(RSpec).to receive(:deprecate)
-  end
-
-  it "is deprecated" do
-    expect(RSpec).to receive(:deprecate).with("any_number_of_times", :replacement => "stub")
-    expect(@mock).to receive(:random_call).any_number_of_times
-  end
-
-  it "passes if any number of times method is called many times" do
-    @mock.should_receive(:random_call).any_number_of_times
-    (1..10).each do
-      @mock.random_call
-    end
-  end
-
-  it "passes if any number of times method is called once" do
-    @mock.should_receive(:random_call).any_number_of_times
-    @mock.random_call
-  end
-
-  it "passes if any number of times method is not called" do
-    @mock.should_receive(:random_call).any_number_of_times
-  end
-
-  it "returns the mocked value when called after a similar stub" do
-    @mock.stub(:message).and_return :stub_value
-    @mock.should_receive(:message).any_number_of_times.and_return(:mock_value)
-    expect(@mock.message).to eq :mock_value
-    expect(@mock.message).to eq :mock_value
-  end
-end

data/spec/rspec/mocks/before_all_spec.rb

@@ -1,74 +0,0 @@
-require 'spec_helper'
-
-describe "using rspec-mocks constructs in before(:all)" do
-  deprecations = []
-
-  def in_rspec_singleton_class(&block)
-    klass = class << ::RSpec; self; end
-    klass.class_eval(&block)
-  end
-
-  before(:all) do
-    in_rspec_singleton_class do
-      alias old_deprecate deprecate
-      undef deprecate
-      define_method(:deprecate) { |*args| deprecations << args.first }
-    end
-  end
-
-  after(:all) do
-    in_rspec_singleton_class do
-      undef deprecate
-      alias deprecate old_deprecate
-      undef old_deprecate
-    end
-  end
-
-  describe "a method stub" do
-    before(:all) do
-      deprecations.clear
-      Object.stub(:foo) { 13 }
-    end
-
-    it 'works in examples and prints a deprecation' do
-      expect(Object.foo).to eq(13)
-      expect(deprecations).to include(match(/outside the per-test lifecycle/))
-    end
-  end
-
-  describe "an any_instance stub" do
-    before(:all) do
-      deprecations.clear
-      Object.any_instance.stub(:foo => 13)
-    end
-
-    it 'works in examples and prints a deprecation' do
-      expect(Object.new.foo).to eq(13)
-      expect(deprecations).to include(match(/outside the per-test lifecycle/))
-    end
-  end
-
-  describe "constant stubbing" do
-    before(:all) do
-      deprecations.clear
-      RSpec::Mocks::ConstantMutator.stub("Foo23", 23)
-    end
-
-    it 'works in examples and prints a deprecation' do
-      expect(Foo23).to eq(23)
-      expect(deprecations).to include(match(/outside the per-test lifecycle/))
-    end
-  end
-
-  describe "constant hiding" do
-    before(:all) do
-      deprecations.clear
-      RSpec::Mocks::ConstantMutator.hide("SomeClass")
-    end
-
-    it 'works in examples and prints a deprecation' do
-      expect(deprecations).to include(match(/outside the per-test lifecycle/))
-    end
-  end
-end
-

data/spec/rspec/mocks/bug_report_10260_spec.rb

@@ -1,8 +0,0 @@
-require 'spec_helper'
-
-describe "An RSpec Mock" do
-  it "hides internals in its inspect representation" do
-    m = double('cup')
-    expect(m.inspect).to match(/#<RSpec::Mocks::Double:0x[a-f0-9.]+ @name="cup">/)
-  end
-end

data/spec/rspec/mocks/bug_report_10263_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe "Double" do
-  let(:test_double) { double }
-
-  specify "when one example has an expectation inside the block passed to should_receive" do
-    test_double.should_receive(:msg) do |arg|
-      expect(arg).to be true #this call exposes the problem
-    end
-    begin
-      test_double.msg(false)
-    rescue Exception
-    end
-  end
-
-  specify "then the next example should behave as expected instead of saying" do
-    test_double.should_receive(:foobar)
-    test_double.foobar
-    verify test_double
-    begin
-      test_double.foobar
-    rescue Exception => e
-      expect(e.message).to eq "Double received unexpected message :foobar with (no args)"
-    end
-  end
-end
-

data/spec/rspec/mocks/bug_report_11545_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-class LiarLiarPantsOnFire
-  def respond_to?(message, incl_private=false)
-    true
-  end
-
-  def self.respond_to?(message, incl_private=false)
-    true
-  end
-end
-
-describe 'should_receive' do
-  before(:each) do
-    @liar = LiarLiarPantsOnFire.new
-  end
-
-  it "works when object lies about responding to a method" do
-    @liar.should_receive(:something)
-    @liar.something
-  end
-
-  it 'works when class lies about responding to a method' do
-    LiarLiarPantsOnFire.should_receive(:something)
-    LiarLiarPantsOnFire.something
-  end
-
-  it 'cleans up after itself' do
-    expect((class << LiarLiarPantsOnFire; self; end).instance_methods).not_to include("something")
-  end
-end
-

data/spec/rspec/mocks/bug_report_496_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-module BugReport496
-  describe "a message expectation on a base class object" do
-    class BaseClass
-    end
-
-    class SubClass < BaseClass
-    end
-
-    it "is received" do
-      BaseClass.should_receive(:new).once
-      SubClass.new
-    end
-  end
-end
-