rspec-mocks 3.0.0.beta2 → 3.0.0.rc1

data/spec/rspec/mocks/verifying_message_expecation_spec.rb

@@ -1,69 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe VerifyingMessageExpectation do
-      describe '#with' do
-        let(:error_generator) { double.as_null_object }
-        let(:string_module_reference) { DirectModuleReference.new(String) }
-
-        subject {
-          null = double.as_null_object
-
-          described_class.new(error_generator, null, null, null)
-        }
-
-        describe 'when expected method is not loaded' do
-          it 'allows any arguments to be expected' do
-            subject.with(:foo, :bar)
-          end
-        end
-
-        describe 'when arity match fails' do
-          it 'raises error' do
-            args = ["abc123", "xyz987"]
-            subject.method_reference = InstanceMethodReference.new(string_module_reference, :replace)
-            expect(error_generator).to receive(:raise_invalid_arguments_error).
-              with(instance_of(MethodSignatureVerifier))
-
-            subject.with(*args)
-          end
-        end
-
-        describe 'when called with arguments' do
-          it 'matches arity against the number of arguments' do
-            subject.method_reference = InstanceMethodReference.new(string_module_reference, :replace)
-            expect(error_generator).not_to receive(:raise_invalid_arguments_error)
-
-            subject.with("abc123")
-          end
-        end
-
-        describe 'when called with any arguments matcher' do
-          it 'does not try to match arity' do
-            subject.method_reference = InstanceMethodReference.new(string_module_reference, :replace)
-            subject.with(any_args)
-          end
-        end
-
-        describe 'when called with no arguments matcher' do
-          it 'matches arity to 0' do
-            subject.method_reference = InstanceMethodReference.new(string_module_reference, :replace)
-            expect(error_generator).to receive(:raise_invalid_arguments_error).
-              with(instance_of(MethodSignatureVerifier))
-
-            subject.with(no_args)
-          end
-        end
-
-        describe 'when called with no arguments and no block' do
-          it 'raises' do
-            expect {
-              subject.with
-            }.to raise_error(ArgumentError)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/rspec/mocks_spec.rb

@@ -1,192 +0,0 @@
-require "spec_helper"
-
-describe RSpec::Mocks do
-  describe ".verify" do
-    it "delegates to the space" do
-      foo = double
-      foo.should_receive(:bar)
-      expect do
-        RSpec::Mocks.verify
-      end.to raise_error(RSpec::Mocks::MockExpectationError)
-
-      RSpec::Mocks.teardown # so the mocks aren't re-verified after this example
-    end
-  end
-
-  describe ".teardown" do
-    it "resets method stubs" do
-      string = "foo"
-      allow(string).to receive(:bar)
-      RSpec::Mocks.teardown
-      expect { string.bar }.to raise_error(NoMethodError)
-    end
-
-    it "does not put rspec-mocks into an inconsistent state when called extra times" do
-      RSpec::Mocks.teardown
-      RSpec::Mocks.teardown
-      RSpec::Mocks.teardown
-
-      string = "foo"
-      expect { allow(string).to receive(:bar) }.to raise_error(RSpec::Mocks::OutsideOfExampleError)
-
-      RSpec::Mocks.setup
-      allow(string).to receive(:bar).and_return(:baz)
-      expect(string.bar).to eq(:baz)
-    end
-  end
-
-  describe ".setup" do
-    it 'starts a new space scope that is later removed by .teardown' do
-      old_space = RSpec::Mocks.space
-      RSpec::Mocks.setup
-
-      new_space = RSpec::Mocks.space
-      expect(new_space).not_to equal(old_space)
-
-      RSpec::Mocks.teardown
-      expect(RSpec::Mocks.space).to equal(old_space)
-    end
-  end
-
-  describe ".configuration" do
-    it 'returns a memoized configuration instance' do
-      expect(RSpec::Mocks.configuration).to be_a(RSpec::Mocks::Configuration)
-      expect(RSpec::Mocks.configuration).to be(RSpec::Mocks.configuration)
-    end
-  end
-
-  describe ".with_temporary_scope" do
-    context "in a before(:all) with a stubbed double" do
-      before(:all) do
-        RSpec::Mocks.with_temporary_scope do
-          @calculator = double
-          allow(@calculator).to receive(:add) { |a, b| a + b }
-          @sum = @calculator.add(3, 4)
-        end
-
-        capture_error { @calculator.add(1, 10) }
-      end
-
-      it 'allows the stubbed double to be used' do
-        expect(@sum).to eq(7)
-      end
-
-      it 'does not allow the double to be used in the examples' do
-        expect {
-          @calculator.add(1, 2)
-        }.to raise_error(RSpec::Mocks::ExpiredTestDoubleError)
-      end
-
-      it 'does not allow the double to be used after the scope in before(:all)' do
-        expect(@error).to be_a(RSpec::Mocks::OutsideOfExampleError)
-      end
-    end
-
-    context "in a before(:all) with a stubbed const" do
-      before(:all) do
-        RSpec::Mocks.with_temporary_scope do
-          stub_const("ValueX", 3)
-          stub_const("ValueY", 4)
-          @sum = ValueX + ValueY
-        end
-
-        capture_error { ValueX + ValueY }
-      end
-
-      it 'allows the stubbed constants to be used' do
-        expect(@sum).to eq(7)
-      end
-
-      it 'does not allow the stubbed constants to be used in the examples' do
-        expect(defined?(ValueX)).to be_falsey
-        expect(defined?(ValueY)).to be_falsey
-      end
-
-      it 'does not allow the stubbed constants to be used after the scope in before(:all)' do
-        expect(@error).to be_a(NameError)
-        expect(@error.message).to include("ValueX")
-      end
-    end
-
-    context "in a before(:all) with a unmet mock expectation" do
-      before(:all) do
-        capture_error do
-          RSpec::Mocks.with_temporary_scope do
-            calculator = double
-            expect(calculator).to receive(:add)
-          end
-        end
-      end
-
-      it 'fails with a mock expectation error' do
-        expect(@error).to be_a(RSpec::Mocks::MockExpectationError)
-      end
-    end
-
-    context "in a before(:all) with an any_instance stub" do
-      before(:all) do
-        RSpec::Mocks.with_temporary_scope do
-          allow_any_instance_of(String).to receive(:sum_with) { |val, x| val + x }
-          @sum = "foo".sum_with("bar")
-        end
-
-        capture_error { "you".sum_with("me") }
-      end
-
-      it 'allows the stub to be used' do
-        expect(@sum).to eq("foobar")
-      end
-
-      it 'does not allow the double to be used in the examples' do
-        expect {
-          "foo".sum_with("baz")
-        }.to raise_error(NameError, /sum_with/)
-      end
-
-      it 'does not allow the double to be used after the scope in before(:all)' do
-        expect(@error).to be_a(NameError)
-        expect(@error.message).to include("sum_with")
-      end
-    end
-
-    it 'tears down even if an error occurs' do
-      foo = Object.new
-
-      expect {
-        RSpec::Mocks.with_temporary_scope do
-          allow(foo).to receive(:bar)
-          raise "boom"
-        end
-      }.to raise_error("boom")
-
-      expect(foo).not_to respond_to(:bar)
-    end
-
-    it 'does not verify if an error occurs before the block completes' do
-      expect {
-        RSpec::Mocks.with_temporary_scope do
-          foo   = Object.new
-          expect(foo).to receive(:bar)
-          raise "boom"
-        end
-      }.to raise_error("boom") # rather than MockExpectationError
-    end
-
-    def capture_error
-      yield
-    rescue Exception => @error
-    end
-  end
-
-  context "when there is a `let` declaration that overrides an argument matcher" do
-    let(:boolean) { :from_let }
-
-    before do
-      expect(RSpec::Mocks::ArgumentMatchers.method_defined?(:boolean)).to be true
-    end
-
-    it 'allows the `let` definition to win' do
-      expect(boolean).to eq(:from_let)
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,121 +0,0 @@
-require 'rspec/support/spec'
-require 'rspec/mocks/ruby_features'
-
-RSpec::Support::Spec.setup_simplecov do
-  minimum_coverage 96
-end
-
-require 'yaml'
-begin
-  require 'psych'
-rescue LoadError
-end
-
-RSpec::Matchers.define :include_method do |expected|
-  match do |actual|
-    actual.map { |m| m.to_s }.include?(expected.to_s)
-  end
-end
-
-module VerifyAndResetHelpers
-  def verify(object)
-    proxy = RSpec::Mocks.space.proxy_for(object)
-    proxy.verify
-  ensure
-    proxy.reset # so it doesn't fail the verify after the example completes
-  end
-
-  def reset(object)
-    RSpec::Mocks.space.proxy_for(object).reset
-  end
-
-  def verify_all
-    RSpec::Mocks.space.verify_all
-  ensure
-    reset_all
-  end
-
-  def reset_all
-    RSpec::Mocks.space.reset_all
-  end
-end
-
-module VerificationHelpers
-  def prevents(&block)
-    expect(&block).to \
-      raise_error(RSpec::Mocks::MockExpectationError)
-  end
-end
-
-require 'rspec/support/spec'
-
-RSpec.configure do |config|
-  config.mock_with :rspec
-  config.color_enabled = true
-  config.order = :random
-
-  config.expect_with :rspec do |expectations|
-    expectations.syntax = :expect
-  end
-
-  # TODO: switch most things to the `expect` syntax (and configure only that here)
-  #       but keep a small number of specs that use the old syntax in order to test it
-  #       (using the "with syntax" shared context defined below).
-  config.mock_with :rspec do |mocks|
-    mocks.syntax = [:should, :expect]
-  end
-
-  old_verbose = nil
-  config.before(:each, :silence_warnings) do
-    old_verbose = $VERBOSE
-    $VERBOSE = nil
-  end
-
-  config.after(:each, :silence_warnings) do
-    $VERBOSE = old_verbose
-  end
-
-  config.include VerifyAndResetHelpers
-  config.include VerificationHelpers
-  config.extend RSpec::Mocks::RubyFeatures
-  config.include RSpec::Mocks::RubyFeatures
-end
-
-shared_context "with syntax" do |syntax|
-  orig_syntax = nil
-
-  before(:all) do
-    orig_syntax = RSpec::Mocks.configuration.syntax
-    RSpec::Mocks.configuration.syntax = syntax
-  end
-
-  after(:all) do
-    RSpec::Mocks.configuration.syntax = orig_syntax
-  end
-end
-
-
-shared_context "with isolated configuration" do
-  orig_configuration = nil
-  before do
-    orig_configuration = RSpec::Mocks.configuration
-    RSpec::Mocks.instance_variable_set(:@configuration, RSpec::Mocks::Configuration.new)
-  end
-
-  after do
-    RSpec::Mocks.instance_variable_set(:@configuration, orig_configuration)
-  end
-end
-
-shared_context "with the default mocks syntax" do
-  orig_syntax = nil
-
-  before(:all) do
-    orig_syntax = RSpec::Mocks.configuration.syntax
-    RSpec::Mocks.configuration.reset_syntaxes_to_default
-  end
-
-  after(:all) do
-    RSpec::Mocks.configuration.syntax = orig_syntax
-  end
-end