opal-rspec 0.4.3 → 0.5.0.beta1

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

@@ -0,0 +1,53 @@
+module RSpec
+  module Mocks
+    RSpec.describe TestDouble do
+      describe "#freeze" do
+        subject { double }
+
+        it "gives a warning" do
+          expect(RSpec).to receive(:warn_with).with(/freeze a test double/)
+          subject.freeze
+        end
+
+        it "gives the correct call site for the warning" do
+          expect_warning_with_call_site(__FILE__, __LINE__+1)
+          subject.freeze
+        end
+
+        it "doesn't freeze the object" do
+          allow(RSpec).to receive(:warn_with).with(/freeze a test double/)
+          double.freeze
+          allow(subject).to receive(:hi)
+
+          expect {
+            subject.hi
+          }.not_to raise_error
+        end
+      end
+
+      RSpec.shared_examples_for "a copy method" do |method|
+        it "copies the `as_null_object` state when #{method}'d" do
+          dbl = double.as_null_object
+          copy = dbl.__send__(method)
+          expect(copy.foo.bar).to be(copy)
+        end
+      end
+
+      include_examples "a copy method", :dup
+      include_examples "a copy method", :clone
+
+      [[:should, :expect], [:expect], [:should]].each do |syntax|
+        context "with syntax #{syntax.inspect}" do
+          include_context "with syntax", syntax
+
+          it 'stubs the methods passed in the stubs hash' do
+            dbl = double("MyDouble", :a => 5, :b => 10)
+
+            expect(dbl.a).to eq(5)
+            expect(dbl.b).to eq(10)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+module RSpec
+  module Mocks
+    RSpec.describe "#thrice" do
+      before(:each) do
+        @double = double("test double")
+      end
+
+      it "passes when called thrice" do
+        expect(@double).to receive(:do_something).thrice
+        3.times { @double.do_something }
+        verify @double
+      end
+
+      it "passes when called thrice with specified args" do
+        expect(@double).to receive(:do_something).thrice.with("1", 1)
+        3.times { @double.do_something("1", 1) }
+        verify @double
+      end
+
+      it "passes when called thrice with unspecified args" do
+        expect(@double).to receive(:do_something).thrice
+        @double.do_something("1")
+        @double.do_something(1)
+        @double.do_something(nil)
+        verify @double
+      end
+
+      it "fails fast when call count is higher than expected" do
+        expect(@double).to receive(:do_something).thrice
+        3.times { @double.do_something }
+        expect {
+          @double.do_something
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "fails when call count is lower than expected" do
+        expect(@double).to receive(:do_something).thrice
+        @double.do_something
+        expect {
+          verify @double
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "fails when called with wrong args on the first call" do
+        expect(@double).to receive(:do_something).thrice.with("1", 1)
+        expect {
+          @double.do_something(1, "1")
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
+        reset @double
+      end
+
+      it "fails when called with wrong args on the second call" do
+        expect(@double).to receive(:do_something).thrice.with("1", 1)
+        @double.do_something("1", 1)
+        expect {
+          @double.do_something(1, "1")
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
+        reset @double
+      end
+
+      it "fails when called with wrong args on the third call" do
+        expect(@double).to receive(:do_something).thrice.with("1", 1)
+        @double.do_something("1", 1)
+        @double.do_something("1", 1)
+        expect {
+          @double.do_something(1, "1")
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
+        reset @double
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+RSpec.describe "a double receiving to_ary" do
+  shared_examples "to_ary" do
+    it "can be overridden with a stub" do
+      allow(obj).to receive(:to_ary) { :non_nil_value }
+      expect(obj.to_ary).to be(:non_nil_value)
+    end
+
+    it "responds when overriden" do
+      allow(obj).to receive(:to_ary) { :non_nil_value }
+      expect(obj).to respond_to(:to_ary)
+    end
+
+    it "supports Array#flatten" do
+      obj = double('foo')
+      expect([obj].flatten).to eq([obj])
+    end
+  end
+
+  context "double as_null_object" do
+    let(:obj) { double('obj').as_null_object }
+    include_examples "to_ary"
+
+    it "does respond to to_ary" do
+      expect(obj).to respond_to(:to_ary)
+    end
+
+    it "does respond to to_a" do
+      expect(obj).to respond_to(:to_a)
+    end
+
+    it "returns nil" do
+      expect(obj.to_ary).to eq nil
+    end
+  end
+
+  context "double without as_null_object" do
+    let(:obj) { double('obj') }
+    include_examples "to_ary"
+
+    it "doesn't respond to to_ary" do
+      expect(obj).not_to respond_to(:to_ary)
+    end
+
+    it "doesn't respond to to_a", :if => ( RUBY_VERSION.to_f > 1.8 ) do
+      expect(obj).not_to respond_to(:to_a)
+    end
+
+    it "raises " do
+      expect { obj.to_ary }.to raise_error(NoMethodError)
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+module RSpec
+  module Mocks
+    RSpec.describe "#twice" do
+      before(:each) do
+        @double = double("test double")
+      end
+
+      it "passes when called twice" do
+        expect(@double).to receive(:do_something).twice
+        @double.do_something
+        @double.do_something
+        verify @double
+      end
+
+      it "passes when called twice with specified args" do
+        expect(@double).to receive(:do_something).twice.with("1", 1)
+        @double.do_something("1", 1)
+        @double.do_something("1", 1)
+        verify @double
+      end
+
+      it "passes when called twice with unspecified args" do
+        expect(@double).to receive(:do_something).twice
+        @double.do_something("1")
+        @double.do_something(1)
+        verify @double
+      end
+
+      it "fails fast when call count is higher than expected" do
+        expect(@double).to receive(:do_something).twice
+        @double.do_something
+        @double.do_something
+        expect {
+          @double.do_something
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "fails when call count is lower than expected" do
+        expect(@double).to receive(:do_something).twice
+        @double.do_something
+        expect {
+          verify @double
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "fails when called with wrong args on the first call" do
+        expect(@double).to receive(:do_something).twice.with("1", 1)
+        expect {
+          @double.do_something(1, "1")
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
+        reset @double
+      end
+
+      it "fails when called with wrong args on the second call" do
+        expect(@double).to receive(:do_something).twice.with("1", 1)
+        @double.do_something("1", 1)
+        expect {
+          @double.do_something(1, "1")
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
+        reset @double
+      end
+    end
+  end
+end

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

@@ -0,0 +1,118 @@
+require 'support/doubled_classes'
+
+module RSpec
+  module Mocks
+    RSpec.describe 'A class 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 = class_double("LoadedClass")
+        expect {
+          o.defined_class_method
+        }.to fail_matching('Double "LoadedClass"')
+      end
+
+      it 'only allows class methods that exist to be stubbed' do
+        o = class_double('LoadedClass', :defined_class_method => 1)
+        expect(o.defined_class_method).to eq(1)
+
+        prevents { allow(o).to receive(:undefined_instance_method) }
+        prevents { allow(o).to receive(:defined_instance_method) }
+      end
+
+      it 'only allows class methods that exist to be expected' do
+        o = class_double('LoadedClass')
+        expect(o).to receive(:defined_class_method)
+        o.defined_class_method
+
+        prevents { expect(o).to receive(:undefined_instance_method) }
+        prevents { expect(o).to receive(:defined_instance_method) }
+        prevents { expect(o).to receive(:undefined_instance_method) }
+        prevents { expect(o).to receive(:defined_instance_method) }
+      end
+
+      it 'gives a descriptive error message for NoMethodError' do
+        o = class_double("LoadedClass")
+        expect {
+          o.defined_private_class_method
+        }.to raise_error(NoMethodError, /Double "LoadedClass"/)
+      end
+
+      it 'checks that stubbed methods are invoked with the correct arity' do
+        o = class_double('LoadedClass', :defined_class_method => 1)
+        expect {
+          o.defined_class_method(:a)
+        }.to raise_error(ArgumentError)
+      end
+
+      it 'allows dynamically defined class method stubs with arguments' do
+        o = class_double('LoadedClass')
+        allow(o).to receive(:dynamic_class_method).with(:a) { 1 }
+
+        expect(o.dynamic_class_method(:a)).to eq(1)
+      end
+
+      it 'allows dynamically defined class method mocks with arguments' do
+        o = class_double('LoadedClass')
+        expect(o).to receive(:dynamic_class_method).with(:a)
+
+        o.dynamic_class_method(:a)
+      end
+
+      it 'allows dynamically defined class methods to be expected' do
+        o = class_double('LoadedClass', :dynamic_class_method => 1)
+        expect(o.dynamic_class_method).to eq(1)
+      end
+
+      it 'allows class to be specified by constant' do
+        o = class_double(LoadedClass, :defined_class_method => 1)
+        expect(o.defined_class_method).to eq(1)
+      end
+
+      it 'can replace existing constants for the duration of the test' do
+        original = LoadedClass
+        object = class_double('LoadedClass').as_stubbed_const
+        expect(object).to receive(:defined_class_method)
+
+        expect(LoadedClass).to eq(object)
+        ::RSpec::Mocks.teardown
+        ::RSpec::Mocks.setup
+        expect(LoadedClass).to eq(original)
+      end
+
+      it 'can transfer nested constants to the double' do
+        class_double("LoadedClass").
+          as_stubbed_const(:transfer_nested_constants => true)
+        expect(LoadedClass::M).to eq(:m)
+        expect(LoadedClass::N).to eq(:n)
+      end
+
+      it 'correctly verifies expectations when constant is removed' do
+        dbl1 = class_double(LoadedClass::Nested).as_stubbed_const
+        class_double(LoadedClass).as_stubbed_const
+
+        prevents {
+          expect(dbl1).to receive(:undefined_class_method)
+        }
+      end
+
+      it 'only allows defined methods for null objects' do
+        o = class_double('LoadedClass').as_null_object
+
+        expect(o.defined_class_method).to eq(o)
+        prevents { o.undefined_method }
+      end
+
+      it 'validates `with` args against the method signature when stubbing a method' do
+        dbl = class_double(LoadedClass)
+        prevents(/Wrong number of arguments. Expected 0, got 2./) {
+          allow(dbl).to receive(:defined_class_method).with(2, :args)
+        }
+      end
+    end
+  end
+end

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

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

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

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