opal-connect-rspec 0.5.0

data/rspec-mocks/spec/rspec/mocks/verifying_doubles/method_visibility_spec.rb

@@ -0,0 +1,129 @@
+require 'support/doubled_classes'
+
+module RSpec
+  module Mocks
+    RSpec.describe "Method visibility for verified doubles" do
+      include_context "with isolated configuration"
+
+      before do
+        RSpec::Mocks.configuration.verify_doubled_constant_names = true
+      end
+
+      context "for an instance double (when the class is loaded)" do
+        shared_examples "preserves method visibility" do |visibility|
+          method_name = :"defined_#{visibility}_method"
+
+          it "can allow a #{visibility} instance method" do
+            o = instance_double('LoadedClass')
+            allow(o).to receive(method_name).and_return(3)
+            expect(o.send method_name).to eq(3)
+          end
+
+          it "can expect a #{visibility} instance method" do
+            o = instance_double('LoadedClass')
+            expect(o).to receive(method_name)
+            o.send method_name
+          end
+
+          it "preserves #{visibility} visibility when allowing a #{visibility} method" do
+            preserves_visibility(method_name, visibility) do
+              instance_double('LoadedClass').tap do |o|
+                allow(o).to receive(method_name)
+              end
+            end
+          end
+
+          it "preserves #{visibility} visibility when expecting a #{visibility} method" do
+            preserves_visibility(method_name, visibility) do
+              instance_double('LoadedClass').tap do |o|
+                expect(o).to receive(method_name).at_least(:once)
+                o.send(method_name) # to satisfy the expectation
+              end
+            end
+          end
+
+          it "preserves #{visibility} visibility on a null object" do
+            preserves_visibility(method_name, visibility) do
+              instance_double('LoadedClass').as_null_object
+            end
+          end
+        end
+
+        include_examples "preserves method visibility", :private
+        include_examples "preserves method visibility", :protected
+      end
+
+      context "for a class double (when the class is loaded)" do
+        shared_examples "preserves method visibility" do |visibility|
+          method_name = :"defined_#{visibility}_class_method"
+
+          it "can allow a #{visibility} instance method" do
+            o = class_double('LoadedClass')
+            allow(o).to receive(method_name).and_return(3)
+            expect(o.send method_name).to eq(3)
+          end
+
+          it "can expect a #{visibility} instance method" do
+            o = class_double('LoadedClass')
+            expect(o).to receive(method_name)
+            o.send method_name
+          end
+
+          it "preserves #{visibility} visibility when allowing a #{visibility} method" do
+            preserves_visibility(method_name, visibility) do
+              class_double('LoadedClass').tap do |o|
+                allow(o).to receive(method_name)
+              end
+            end
+          end
+
+          it "preserves #{visibility} visibility when expecting a #{visibility} method" do
+            preserves_visibility(method_name, visibility) do
+              class_double('LoadedClass').tap do |o|
+                expect(o).to receive(method_name).at_least(:once)
+                o.send(method_name) # to satisfy the expectation
+              end
+            end
+          end
+
+          it "preserves #{visibility} visibility on a null object" do
+            preserves_visibility(method_name, visibility) do
+              class_double('LoadedClass').as_null_object
+            end
+          end
+        end
+
+        include_examples "preserves method visibility", :private
+        include_examples "preserves method visibility", :protected
+      end
+
+      def preserves_visibility(method_name, visibility)
+        double = yield
+
+        expect {
+          # send bypasses visbility, so we use eval instead.
+          eval("double.#{method_name}")
+        }.to raise_error(NoMethodError, a_message_indicating_visibility_violation(method_name, visibility))
+
+        expect { double.send(method_name) }.not_to raise_error
+        expect { double.__send__(method_name) }.not_to raise_error
+
+        unless double.null_object?
+          # Null object doubles use `method_missing` and so the singleton class
+          # doesn't know what methods are defined.
+          singleton_class = class << double; self; end
+          expect(singleton_class.send("#{visibility}_method_defined?", method_name)).to be true
+        end
+      end
+
+      RSpec::Matchers.define :a_message_indicating_visibility_violation do |method_name, visibility|
+        match do |msg|
+          # This should NOT Be just `msg.match(visibility)` because the method being called
+          # has the visibility name in it. We want to ensure it's a message that ruby is
+          # stating is of the given visibility.
+          msg.match("#{visibility} ") && msg.match(method_name.to_s)
+        end
+      end
+    end
+  end
+end

data/rspec-mocks/spec/rspec/mocks/verifying_doubles/object_double_spec.rb

@@ -0,0 +1,68 @@
+require 'support/doubled_classes'
+
+module RSpec
+  module Mocks
+    RSpec.describe 'An object double' do
+      it 'can replace an unloaded constant' do
+        o = object_double("LoadedClass::NOINSTANCE").as_stubbed_const
+
+        expect(LoadedClass::NOINSTANCE).to eq(o)
+
+        expect(o).to receive(:undefined_instance_method)
+        o.undefined_instance_method
+      end
+
+      it 'can replace a constant by name and verify instance methods' do
+        o = object_double("LoadedClass::INSTANCE").as_stubbed_const
+
+        expect(LoadedClass::INSTANCE).to eq(o)
+
+        prevents { expect(o).to receive(:undefined_instance_method) }
+        prevents { expect(o).to receive(:defined_class_method) }
+        prevents { o.defined_instance_method }
+
+        expect(o).to receive(:defined_instance_method)
+        o.defined_instance_method
+        expect(o).to receive(:defined_private_method)
+        o.send :defined_private_method
+      end
+
+      it 'can create a double that matches the interface of any arbitrary object' do
+        o = object_double(LoadedClass.new)
+
+        prevents { expect(o).to receive(:undefined_instance_method) }
+        prevents { expect(o).to receive(:defined_class_method) }
+        prevents { o.defined_instance_method }
+
+        expect(o).to receive(:defined_instance_method)
+        o.defined_instance_method
+        expect(o).to receive(:defined_private_method)
+        o.send :defined_private_method
+      end
+
+      it 'does not allow transferring constants to an object' do
+        expect {
+          object_double("LoadedClass::INSTANCE").
+            as_stubbed_const(:transfer_nested_constants => true)
+        }.to raise_error(/Cannot transfer nested constants/)
+      end
+
+      it 'does not allow as_stubbed_constant for real objects' do
+        expect {
+          object_double(LoadedClass.new).as_stubbed_const
+        }.to raise_error(/Can not perform constant replacement with an object/)
+      end
+
+      it 'is not a module' do
+        expect(object_double("LoadedClass::INSTANCE")).to_not be_a(Module)
+      end
+
+      it 'validates `with` args against the method signature when stubbing a method' do
+        dbl = object_double(LoadedClass.new)
+        prevents(/Wrong number of arguments. Expected 2, got 3./) {
+          allow(dbl).to receive(:instance_method_with_two_args).with(3, :foo, :args)
+        }
+      end
+    end
+  end
+end

data/rspec-mocks/spec/rspec/mocks_spec.rb

@@ -0,0 +1,199 @@
+require 'rspec/support/spec/prevent_load_time_warnings'
+
+RSpec.describe RSpec::Mocks do
+  it_behaves_like 'a library that issues no warnings when loaded',
+    'rspec-mocks', 'require "rspec/mocks"',
+    # Must be required before other files due to how our autoloads are setup.
+    # (Users won't hit this problem because they won't require all the files
+    # individually in whatever order the file system returns)
+    'require "rspec/mocks/any_instance"'
+
+  describe ".verify" do
+    it "delegates to the space" do
+      foo = double
+      expect(foo).to 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/rspec-mocks/spec/spec_helper.rb

@@ -0,0 +1,131 @@
+require 'rspec/support/spec'
+require 'rspec/support/ruby_features'
+
+RSpec::Support::Spec.setup_simplecov do
+  minimum_coverage 95
+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
+require 'support/matchers'
+
+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(msg = //, &block)
+    expect(&block).to \
+      raise_error(RSpec::Mocks::MockExpectationError, msg)
+  end
+end
+
+require 'rspec/support/spec'
+
+RSpec.configure do |config|
+  config.expose_dsl_globally = false
+  config.mock_with :rspec
+  config.color = true
+  config.order = :random
+
+  config.expect_with :rspec do |expectations|
+    expectations.syntax = :expect
+  end
+
+  config.mock_with :rspec do |mocks|
+    $default_rspec_mocks_syntax = mocks.syntax
+    mocks.syntax = :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::Support::RubyFeatures
+  config.include RSpec::Support::RubyFeatures
+end
+
+RSpec.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
+
+
+RSpec.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
+
+RSpec.shared_context "with monkey-patched marshal" do
+  before do
+    RSpec::Mocks.configuration.patch_marshal_to_support_partial_doubles = true
+  end
+
+  after do
+    RSpec::Mocks.configuration.patch_marshal_to_support_partial_doubles = false
+  end
+end
+
+RSpec.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