opal-rspec 0.4.3 → 0.5.0.beta1

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

@@ -0,0 +1,195 @@
+require 'support/doubled_classes'
+
+module RSpec
+  module Mocks
+    RSpec.describe 'An instance double with the doubled class loaded' do
+      include_context "with isolated configuration"
+
+      before do
+        RSpec::Mocks.configuration.verify_doubled_constant_names = true
+      end
+
+      it 'includes the double name in errors for unexpected messages' do
+        o = instance_double("LoadedClass")
+        expect {
+          o.defined_instance_method
+        }.to fail_matching('Double "LoadedClass (instance)"')
+      end
+
+      it 'only allows instance methods that exist to be stubbed' do
+        o = instance_double('LoadedClass', :defined_instance_method => 1)
+        expect(o.defined_instance_method).to eq(1)
+
+        prevents { allow(o).to receive(:undefined_instance_method) }
+        prevents { allow(o).to receive(:defined_class_method) }
+      end
+
+      it 'only allows instance methods that exist to be expected' do
+        o = instance_double('LoadedClass')
+        expect(o).to receive(:defined_instance_method)
+        o.defined_instance_method
+
+        prevents { expect(o).to receive(:undefined_instance_method) }
+        prevents { expect(o).to receive(:defined_class_method) }
+        prevents { expect(o).to receive(:undefined_instance_method) }
+        prevents { expect(o).to receive(:defined_class_method) }
+      end
+
+      it 'allows `send` to be stubbed if it is defined on the class' do
+        o = instance_double('LoadedClass')
+        allow(o).to receive(:send).and_return("received")
+        expect(o.send(:msg)).to eq("received")
+      end
+
+      it 'gives a descriptive error message for NoMethodError' do
+        o = instance_double("LoadedClass")
+        expect {
+          o.defined_private_method
+        }.to raise_error(NoMethodError,
+                           /Double "LoadedClass \(instance\)"/)
+      end
+
+      it 'does not allow dynamic methods to be expected' do
+        # This isn't possible at the moment since an instance of the class
+        # would be required for the verification, and we only have the
+        # class itself.
+        #
+        # This spec exists as "negative" documentation of the absence of a
+        # feature, to highlight the asymmetry from class doubles (that do
+        # support this behaviour).
+        prevents {
+          instance_double('LoadedClass', :dynamic_instance_method => 1)
+        }
+      end
+
+      it 'checks the arity of stubbed methods' do
+        o = instance_double('LoadedClass')
+        prevents {
+          expect(o).to receive(:defined_instance_method).with(:a)
+        }
+      end
+
+      it 'checks that stubbed methods are invoked with the correct arity' do
+        o = instance_double('LoadedClass', :defined_instance_method => 25)
+        expect {
+          o.defined_instance_method(:a)
+        }.to raise_error(ArgumentError,
+                           "Wrong number of arguments. Expected 0, got 1.")
+      end
+
+      if required_kw_args_supported?
+        it 'allows keyword arguments' do
+          o = instance_double('LoadedClass', :kw_args_method => true)
+          expect(o.kw_args_method(1, :required_arg => 'something')).to eq(true)
+        end
+
+        context 'for a method that only accepts keyword args' do
+          it 'allows hash matchers like `hash_including` to be used in place of the keywords arg hash' do
+            o = instance_double('LoadedClass')
+            expect(o).to receive(:kw_args_method).
+              with(1, hash_including(:required_arg => 1))
+            o.kw_args_method(1, :required_arg => 1)
+          end
+
+          it 'allows anything matcher to be used in place of the keywords arg hash' do
+            o = instance_double('LoadedClass')
+            expect(o).to receive(:kw_args_method).with(1, anything)
+            o.kw_args_method(1, :required_arg => 1)
+          end
+
+          it 'still checks positional arguments when matchers used for keyword args' do
+            o = instance_double('LoadedClass')
+            prevents(/Expected 1, got 3/) {
+              expect(o).to receive(:kw_args_method).
+                with(1, 2, 3, hash_including(:required_arg => 1))
+            }
+          end
+
+          it 'does not allow matchers to be used in an actual method call' do
+            o = instance_double('LoadedClass')
+            matcher = hash_including(:required_arg => 1)
+            allow(o).to receive(:kw_args_method).with(1, matcher)
+            expect {
+              o.kw_args_method(1, matcher)
+            }.to raise_error(ArgumentError)
+          end
+        end
+
+        context 'for a method that accepts a mix of optional keyword and positional args' do
+          it 'allows hash matchers like `hash_including` to be used in place of the keywords arg hash' do
+            o = instance_double('LoadedClass')
+            expect(o).to receive(:mixed_args_method).with(1, 2, hash_including(:optional_arg_1 => 1))
+            o.mixed_args_method(1, 2, :optional_arg_1 => 1)
+          end
+        end
+
+        it 'checks that stubbed methods with required keyword args are ' +
+           'invoked with the required arguments' do
+          o = instance_double('LoadedClass', :kw_args_method => true)
+          expect {
+            o.kw_args_method(:optional_arg => 'something')
+          }.to raise_error(ArgumentError)
+        end
+      end
+
+      it 'validates `with` args against the method signature when stubbing a method' do
+        dbl = instance_double(LoadedClass)
+        prevents(/Wrong number of arguments. Expected 2, got 3./) {
+          allow(dbl).to receive(:instance_method_with_two_args).with(3, :foo, :args)
+        }
+      end
+
+      it 'allows class to be specified by constant' do
+        o = instance_double(LoadedClass, :defined_instance_method => 1)
+        expect(o.defined_instance_method).to eq(1)
+      end
+
+      context 'for null objects' do
+        let(:o) { instance_double('LoadedClass').as_null_object }
+
+        it 'only allows defined methods' do
+          expect(o.defined_instance_method).to eq(o)
+          prevents { o.undefined_method }
+          prevents { o.send(:undefined_method) }
+          prevents { o.__send__(:undefined_method) }
+        end
+
+        it "includes the double's name in a private method error" do
+          expect {
+            o.rand
+          }.to raise_error(NoMethodError, %r{private.*Double "LoadedClass \(instance\)"})
+        end
+
+        it 'reports what public messages it responds to accurately' do
+          expect(o.respond_to?(:defined_instance_method)).to be true
+          expect(o.respond_to?(:defined_instance_method, true)).to be true
+          expect(o.respond_to?(:defined_instance_method, false)).to be true
+
+          expect(o.respond_to?(:undefined_method)).to be false
+          expect(o.respond_to?(:undefined_method, true)).to be false
+          expect(o.respond_to?(:undefined_method, false)).to be false
+        end
+
+        it 'reports that it responds to defined private methods when the appropriate arg is passed' do
+          expect(o.respond_to?(:defined_private_method)).to be false
+          expect(o.respond_to?(:defined_private_method, true)).to be true
+          expect(o.respond_to?(:defined_private_method, false)).to be false
+        end
+
+        if RUBY_VERSION.to_f < 2.0 # respond_to?(:protected_method) changed behavior in Ruby 2.0.
+          it 'reports that it responds to protected methods' do
+            expect(o.respond_to?(:defined_protected_method)).to be true
+            expect(o.respond_to?(:defined_protected_method, true)).to be true
+            expect(o.respond_to?(:defined_protected_method, false)).to be true
+          end
+        else
+          it 'reports that it responds to protected methods when the appropriate arg is passed' do
+            expect(o.respond_to?(:defined_protected_method)).to be false
+            expect(o.respond_to?(:defined_protected_method, true)).to be true
+            expect(o.respond_to?(:defined_protected_method, false)).to be false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+require 'support/doubled_classes'
+
+module RSpec
+  module Mocks
+    RSpec.describe 'An instance double with the doubled class not loaded' do
+      include_context "with isolated configuration"
+
+      before do
+        RSpec::Mocks.configuration.verify_doubled_constant_names = false
+      end
+
+      it 'includes the double name in errors for unexpected messages' do
+        o = instance_double("NonLoadedClass")
+        expect {
+          o.foo
+        }.to fail_matching('Double "NonLoadedClass (instance)"')
+      end
+
+      it 'allows any instance method to be stubbed' do
+        o = instance_double('NonloadedClass')
+        allow(o).to receive(:undefined_instance_method).with(:arg).and_return(true)
+        expect(o.undefined_instance_method(:arg)).to eq(true)
+      end
+
+      it 'allows any instance method to be expected' do
+        o = instance_double("NonloadedClass")
+
+        expect(o).to receive(:undefined_instance_method).
+                       with(:arg).
+                       and_return(true)
+
+        expect(o.undefined_instance_method(:arg)).to eq(true)
+      end
+
+      it 'handles classes that are materialized after mocking' do
+        stub_const "A::B", Object.new
+        o = instance_double "A", :undefined_instance_method => true
+
+        expect(o.undefined_instance_method).to eq(true)
+      end
+
+      context 'for null objects' do
+        let(:o) { instance_double('NonLoadedClass').as_null_object }
+
+        it 'returns self from any message' do
+          expect(o.a.b.c).to be(o)
+        end
+
+        it 'reports it responds to any message' do
+          expect(o.respond_to?(:a)).to be true
+          expect(o.respond_to?(:a, false)).to be true
+          expect(o.respond_to?(:a, true)).to be true
+        end
+      end
+    end
+  end
+end

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