opal-rspec 0.6.2 → 0.7.0.rc.1

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

@@ -1,58 +0,0 @@
-require 'support/doubled_classes'
-
-module RSpec
-  module Mocks
-    RSpec.describe 'A class 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 = class_double("NonLoadedClass")
-        expect {
-          o.foo
-        }.to fail_matching('Double "NonLoadedClass"')
-      end
-
-      it 'allows any method to be stubbed' do
-        o = class_double('NonloadedClass')
-        allow(o).to receive(:undefined_instance_method).with(:arg).and_return(1)
-        expect(o.undefined_instance_method(:arg)).to eq(1)
-      end
-
-      specify "trying to raise a class_double raises a TypeError", :unless => RUBY_VERSION == '1.9.2' do
-        subject = Object.new
-        class_double("StubbedError").as_stubbed_const
-        allow(subject).to receive(:some_method).and_raise(StubbedError)
-        expect { subject.some_method }.to raise_error(TypeError, 'exception class/object expected')
-      end
-
-      context "when stubbing a private module method" do
-        before(:all) do
-          Module.class_exec do
-            private
-            def use; end
-          end
-        end
-
-        after(:all) do
-          Module.class_exec do
-            undef use
-          end
-        end
-
-        it 'can mock private module methods' do
-          double = Module.new
-          allow(double).to receive(:use)
-          expect { double.use }.to raise_error(/private method `use' called/)
-
-          double = class_double("NonloadedClass")
-          expect(double).to receive(:use).and_return(:ok)
-          expect(double.use).to be(:ok)
-        end
-      end
-    end
-  end
-end

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

@@ -1,54 +0,0 @@
-require 'support/doubled_classes'
-
-module RSpec
-  module Mocks
-    RSpec.describe 'Constructing a verifying double' do
-      describe 'instance doubles' do
-        it 'cannot be constructed with a non-module object' do
-          expect {
-            instance_double(Object.new)
-          }.to raise_error(/Module or String expected/)
-        end
-
-        it 'can be constructed with a struct' do
-          o = instance_double(Struct.new(:defined_method), :defined_method => 1)
-
-          expect(o.defined_method).to eq(1)
-        end
-      end
-
-      describe 'class doubles' do
-        it 'cannot be constructed with a non-module object' do
-          expect {
-            class_double(Object.new)
-          }.to raise_error(/Module or String expected/)
-        end
-      end
-
-      describe 'when verify_doubled_constant_names config option is set' do
-        include_context "with isolated configuration"
-
-        before do
-          RSpec::Mocks.configuration.verify_doubled_constant_names = true
-        end
-
-        it 'prevents creation of instance doubles for unloaded constants' do
-          expect {
-            instance_double('LoadedClas')
-          }.to raise_error(VerifyingDoubleNotDefinedError)
-        end
-
-        it 'prevents creation of class doubles for unloaded constants' do
-          expect {
-            class_double('LoadedClas')
-          }.to raise_error(VerifyingDoubleNotDefinedError)
-        end
-      end
-
-      it 'can only be named with a string or a module' do
-        expect { instance_double(1) }.to raise_error(ArgumentError)
-        expect { instance_double(nil) }.to raise_error(ArgumentError)
-      end
-    end
-  end
-end

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

@@ -1,81 +0,0 @@
-require 'support/doubled_classes'
-
-module RSpec
-  module Mocks
-    RSpec.describe 'Expected argument verification (when `#with` is called)' do
-      # Note: these specs here aren't meant to be exhaustive. The specs in
-      # rspec-support for the method signature verifier are. Here we are just
-      # covering the code paths within the `with` implementation, including
-      # the special handling for `any_args` and `no_args`.
-      context "when doubling an unloaded class" do
-        it 'allows any arguments' do
-          expect(defined?(UnloadedClass)).to be_falsey
-          dbl = instance_double("UnloadedClass")
-
-          expect {
-            expect(dbl).to receive(:message).with(:foo, :bar, :bazz)
-          }.not_to raise_error
-
-          reset dbl
-        end
-      end
-
-      context "when doubling a loaded class" do
-        let(:dbl) { instance_double(LoadedClass) }
-        after { reset dbl }
-
-        context "when `any_args` is used" do
-          it "skips verification" do
-            expect {
-              expect(dbl).to receive(:instance_method_with_two_args).with(any_args)
-            }.not_to raise_error
-          end
-        end
-
-        context "when `no_args` is used" do
-          it "allows a method expectation on a method that accepts no arguments" do
-            expect(LoadedClass.instance_method(:defined_instance_method).arity).to eq(0)
-
-            expect {
-              expect(dbl).to receive(:defined_instance_method).with(no_args)
-            }.not_to raise_error
-          end
-
-          it "allows a method expectation on a method that has defaults for all arguments" do
-            expect {
-              expect(dbl).to receive(:instance_method_with_only_defaults).with(no_args)
-            }.not_to raise_error
-          end
-
-          it "does not allow a method expectation on a method that has required arguments" do
-            expect {
-              expect(dbl).to receive(:instance_method_with_two_args).with(no_args)
-            }.to fail_with("Wrong number of arguments. Expected 2, got 0.")
-          end
-        end
-
-        context "when a list of args is provided" do
-          it "allows a method expectation when the arity matches" do
-            expect {
-              expect(dbl).to receive(:instance_method_with_two_args).with(1, 2)
-            }.not_to raise_error
-          end
-
-          it "does not allow a method expectation with an arity mismatch" do
-            expect {
-              expect(dbl).to receive(:instance_method_with_two_args).with(1, 2, 3)
-            }.to fail_with("Wrong number of arguments. Expected 2, got 3.")
-          end
-        end
-
-        context "when `with` is called with no args" do
-          it "fails with an error suggesting the user use `no_args` instead" do
-            expect {
-              expect(dbl).to receive(:instance_method_with_two_args).with
-            }.to raise_error(ArgumentError, /no_args/)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,195 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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