opal-rspec 0.4.3 → 0.5.0.beta1

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

@@ -0,0 +1,75 @@
+require 'support/before_all_shared_example_group'
+
+RSpec.describe "Using rspec-mocks features in before(:all) blocks" do
+  describe "#stub_const" do
+    include_examples "fails in a before(:all) block" do
+      def use_rspec_mocks
+        stub_const("SomeNewConst", Class.new)
+      end
+
+      it 'does not stub the const' do
+        expect(defined?(SomeNewConst)).to be_falsey
+      end
+    end
+  end
+
+  describe "#hide_const(for an undefined const)" do
+    include_examples "fails in a before(:all) block" do
+      def use_rspec_mocks
+        hide_const("Foo")
+      end
+    end
+  end
+
+  describe "#hide_const(for a defined const)" do
+    include_examples "fails in a before(:all) block" do
+      def use_rspec_mocks
+        hide_const("Float")
+      end
+
+      it 'does not hide the const' do
+        expect(defined?(Float)).to be_truthy
+      end
+    end
+  end
+
+  describe "allow(...).to receive_message_chain" do
+    include_examples "fails in a before(:all) block" do
+      def use_rspec_mocks
+        allow(Object).to receive_message_chain(:foo, :bar)
+      end
+    end
+  end
+
+  describe "#expect(...).to receive" do
+    include_examples "fails in a before(:all) block" do
+      def use_rspec_mocks
+        expect(Object).to receive(:foo)
+      end
+    end
+  end
+
+  describe "#allow(...).to receive" do
+    include_examples "fails in a before(:all) block" do
+      def use_rspec_mocks
+        allow(Object).to receive(:foo)
+      end
+    end
+  end
+
+  describe "#expect_any_instance_of(...).to receive" do
+    include_examples "fails in a before(:all) block" do
+      def use_rspec_mocks
+        expect_any_instance_of(Object).to receive(:foo)
+      end
+    end
+  end
+
+  describe "#allow_any_instance_of(...).to receive" do
+    include_examples "fails in a before(:all) block" do
+      def use_rspec_mocks
+        allow_any_instance_of(Object).to receive(:foo)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+RSpec.describe "a double declaration with a block handed to:" do
+  describe "expect(...).to receive" do
+    it "returns the value of executing the block" do
+      obj = Object.new
+      expect(obj).to receive(:foo) { 'bar' }
+      expect(obj.foo).to eq('bar')
+    end
+
+    it "works when a multi-return stub has already been set" do
+      obj = Object.new
+      return_value = Object.new
+      allow(obj).to receive(:foo).and_return(return_value, nil)
+      expect(obj).to receive(:foo) { return_value }
+      expect(obj.foo).to be(return_value)
+    end
+  end
+
+  describe "allow(...).to receive" do
+    it "returns the value of executing the block" do
+      obj = Object.new
+      allow(obj).to receive(:foo) { 'bar' }
+      expect(obj.foo).to eq('bar')
+    end
+
+    # The "receives a block" part is important: 1.8.7 has a bug that reports the
+    # wrong arity when a block receives a block.
+    it 'forwards all given args to the block, even when it receives a block' do
+      obj = Object.new
+      yielded_args = []
+      allow(obj).to receive(:foo) { |*args, &bl| yielded_args << args }
+      obj.foo(1, 2, 3)
+
+      expect(yielded_args).to eq([[1, 2, 3]])
+    end
+  end
+
+  describe "with" do
+    it "returns the value of executing the block" do
+      obj = Object.new
+      allow(obj).to receive(:foo).with('baz') { 'bar' }
+      expect(obj.foo('baz')).to eq('bar')
+    end
+
+    it "returns the value of executing the block with given argument" do
+      obj = Object.new
+      allow(obj).to receive(:foo).with('baz') {|x| 'bar' + x }
+      expect(obj.foo('baz')).to eq('barbaz')
+    end
+  end
+
+  %w[once twice ordered].each do |method|
+    describe method do
+      it "returns the value of executing the block" do
+        obj = Object.new
+        allow(obj).to receive(:foo).send(method) { 'bar' }
+        expect(obj.foo).to eq('bar')
+      end
+    end
+  end
+
+  describe "times" do
+    it "returns the value of executing the block" do
+      obj = Object.new
+      allow(obj).to receive(:foo).at_least(1).times { 'bar' }
+      expect(obj.foo('baz')).to eq('bar')
+    end
+  end
+end

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

@@ -0,0 +1,196 @@
+module RSpec
+  module Mocks
+    RSpec.describe "Combining implementation instructions" do
+      it 'can combine and_yield and and_return' do
+        dbl = double
+        allow(dbl).to receive(:foo).and_yield(5).and_return(3)
+
+        expect { |b|
+          expect(dbl.foo(&b)).to eq(3)
+        }.to yield_with_args(5)
+      end
+
+      describe "combining and_yield, a block implementation and and_return" do
+        def verify_combined_implementation
+          dbl = double
+          (yield dbl).and_yield(5).and_return(3)
+
+          expect { |b|
+            expect(dbl.foo(:arg, &b)).to eq(3)
+          }.to yield_with_args(5)
+
+          expect(@block_called).to be_truthy
+        end
+
+        it 'works when passing a block to `stub`' do
+          verify_combined_implementation do |dbl|
+            allow(dbl).to receive(:foo) { @block_called = true }
+          end
+        end
+
+        it 'works when passing a block to `with`' do
+          verify_combined_implementation do |dbl|
+            allow(dbl).to receive(:foo).with(:arg) { @block_called = true }
+          end
+        end
+
+        it 'works when passing a block to `exactly`' do
+          verify_combined_implementation do |dbl|
+            expect(dbl).to receive(:foo).exactly(:once) { @block_called = true }
+          end
+        end
+
+        it 'works when passing a block to `at_least`' do
+          verify_combined_implementation do |dbl|
+            expect(dbl).to receive(:foo).at_least(:once) { @block_called = true }
+          end
+        end
+
+        it 'works when passing a block to `at_most`' do
+          verify_combined_implementation do |dbl|
+            expect(dbl).to receive(:foo).at_most(:once) { @block_called = true }
+          end
+        end
+
+        it 'works when passing a block to `times`' do
+          verify_combined_implementation do |dbl|
+            expect(dbl).to receive(:foo).exactly(1).times { @block_called = true }
+          end
+        end
+
+        it 'works when passing a block to `once`' do
+          verify_combined_implementation do |dbl|
+            expect(dbl).to receive(:foo).once { @block_called = true }
+          end
+        end
+
+        it 'works when passing a block to `twice`' do
+          the_double = nil
+
+          verify_combined_implementation do |dbl|
+            the_double = dbl
+            expect(dbl).to receive(:foo).twice { @block_called = true }
+          end
+
+          the_double.foo { |a| } # to ensure it is called twice
+        end
+
+        it 'works when passing a block to `ordered`' do
+          verify_combined_implementation do |dbl|
+            expect(dbl).to receive(:foo).ordered { @block_called = true }
+          end
+        end
+      end
+
+      it 'can combine and_yield and and_raise' do
+        dbl = double
+        allow(dbl).to receive(:foo).and_yield(5).and_raise("boom")
+
+        expect { |b|
+          expect { dbl.foo(&b) }.to raise_error("boom")
+        }.to yield_with_args(5)
+      end
+
+      it 'can combine and_yield, a block implementation and and_raise' do
+        dbl = double
+        block_called = false
+        allow(dbl).to receive(:foo) { block_called = true }.and_yield(5).and_raise("boom")
+
+        expect { |b|
+          expect { dbl.foo(&b) }.to raise_error("boom")
+        }.to yield_with_args(5)
+
+        expect(block_called).to be_truthy
+      end
+
+      it 'can combine and_yield and and_throw' do
+        dbl = double
+        allow(dbl).to receive(:foo).and_yield(5).and_throw(:bar)
+
+        expect { |b|
+          expect { dbl.foo(&b) }.to throw_symbol(:bar)
+        }.to yield_with_args(5)
+      end
+
+      it 'can combine and_yield, a block implementation and and_throw' do
+        dbl = double
+        block_called = false
+        allow(dbl).to receive(:foo) { block_called = true }.and_yield(5).and_throw(:bar)
+
+        expect { |b|
+          expect { dbl.foo(&b) }.to throw_symbol(:bar)
+        }.to yield_with_args(5)
+
+        expect(block_called).to be_truthy
+      end
+
+      it 'allows the terminal action to be overriden' do
+        dbl = double
+        stubbed_double = allow(dbl).to receive(:foo)
+
+        stubbed_double.and_return(1)
+        expect(dbl.foo).to eq(1)
+
+        stubbed_double.and_return(3)
+        expect(dbl.foo).to eq(3)
+
+        stubbed_double.and_raise("boom")
+        expect { dbl.foo }.to raise_error("boom")
+
+        stubbed_double.and_throw(:bar)
+        expect { dbl.foo }.to throw_symbol(:bar)
+      end
+
+      it 'allows the inner implementation block to be overriden' do
+        allow(RSpec).to receive(:warning)
+        dbl = double
+        stubbed_double = allow(dbl).to receive(:foo)
+
+        stubbed_double.with(:arg) { :with_block }
+        expect(dbl.foo(:arg)).to eq(:with_block)
+
+        stubbed_double.at_least(:once) { :at_least_block }
+        expect(dbl.foo(:arg)).to eq(:at_least_block)
+      end
+
+      it 'warns when the inner implementation block is overriden' do
+        expect(RSpec).to receive(:warning).with(/overriding a previous stub implementation of `foo`.*#{__FILE__}:#{__LINE__ + 1}/)
+        allow(double).to receive(:foo).with(:arg) { :with_block }.at_least(:once) { :at_least_block }
+      end
+
+      it "does not warn about overriding the stub when `:with` is chained off the block" do
+        expect(RSpec).not_to receive(:warning)
+
+        obj = Object.new
+        stub = allow(obj).to receive(:foo) { }
+        stub.with(1)
+      end
+
+      it 'can combine and_call_original, with, and_return' do
+        obj = Struct.new(:value).new('original')
+        allow(obj).to receive(:value).and_call_original
+        allow(obj).to receive(:value).with(:arg).and_return('value')
+        expect(obj.value).to eq 'original'
+        expect(obj.value(:arg)).to eq 'value'
+      end
+
+      it 'raises an error if `and_call_original` is followed by any other instructions' do
+        allow(RSpec).to receive(:warning)
+        dbl = [1, 2, 3]
+        stubbed = allow(dbl).to receive(:size)
+        stubbed.and_call_original
+
+        msg_fragment = /cannot be modified further/
+
+        expect { stubbed.and_yield }.to raise_error(msg_fragment)
+        expect { stubbed.and_return(1) }.to raise_error(msg_fragment)
+        expect { stubbed.and_raise("a") }.to raise_error(msg_fragment)
+        expect { stubbed.and_throw(:bar) }.to raise_error(msg_fragment)
+
+        expect { stubbed.once { } }.to raise_error(msg_fragment)
+
+        expect(dbl.size).to eq(3)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,175 @@
+module RSpec
+  module Mocks
+    RSpec.describe Configuration do
+      let(:config) { Configuration.new }
+      let(:mod_1)  { Module.new }
+      let(:mod_2)  { Module.new }
+
+      def instance_methods_of(mod)
+        mod_1.instance_methods.map(&:to_sym)
+      end
+
+      it 'adds stub and should_receive to the given modules' do
+        expect(instance_methods_of(mod_1)).not_to include(:stub, :should_receive)
+        expect(instance_methods_of(mod_2)).not_to include(:stub, :should_receive)
+
+        config.add_stub_and_should_receive_to(mod_1, mod_2)
+
+        expect(instance_methods_of(mod_1)).to include(:stub, :should_receive)
+        expect(instance_methods_of(mod_2)).to include(:stub, :should_receive)
+      end
+
+      shared_examples "configuring the syntax" do
+        def sandboxed
+          orig_syntax = RSpec::Mocks.configuration.syntax
+          yield
+        ensure
+          configure_syntax(orig_syntax)
+        end
+
+        around(:each) { |ex| sandboxed(&ex) }
+        let(:dbl) { double }
+        let(:should_methods)       { [:should_receive, :stub, :should_not_receive] }
+        let(:should_class_methods) { [:any_instance] }
+        let(:expect_methods)      { [:receive, :allow, :expect_any_instance_of, :allow_any_instance_of] }
+
+        it 'defaults to enabling both the :should and :expect syntaxes' do
+          # This is kinda a hack, but since we want to enforce use of
+          # the expect syntax within our specs here, we have modified the
+          # config setting, which makes it hard to get at the original
+          # default value. in spec_helper.rb we store the default value
+          # in $default_rspec_mocks_syntax so we can use it here.
+          RSpec::Mocks.configuration.syntax = $default_rspec_mocks_syntax
+          expect(dbl).to respond_to(*should_methods)
+          expect(self).to respond_to(*expect_methods)
+        end
+
+        context 'when configured to :expect' do
+          before { configure_syntax :expect }
+
+          it 'removes the should methods from every object' do
+            expect(dbl).not_to respond_to(*should_methods)
+          end
+
+          it 'removes `any_instance` from every class' do
+            expect(Class.new).not_to respond_to(*should_class_methods)
+          end
+
+          it 'adds the expect methods to the example group context' do
+            expect(self).to respond_to(*expect_methods)
+          end
+
+          it 'reports that the syntax is :expect' do
+            expect(configured_syntax).to eq([:expect])
+          end
+
+          it 'is a no-op when configured a second time' do
+            expect(Syntax.default_should_syntax_host).not_to receive(:method_undefined)
+            expect(::RSpec::Mocks::ExampleMethods).not_to receive(:method_added)
+            configure_syntax :expect
+          end
+        end
+
+        context 'when configured to :should' do
+          before { configure_syntax :should }
+
+          it 'adds the should methods to every object' do
+            expect(dbl).to respond_to(*should_methods)
+          end
+
+          it 'adds `any_instance` to every class' do
+            expect(Class.new).to respond_to(*should_class_methods)
+          end
+
+          it 'removes the expect methods from the example group context' do
+            expect(self).not_to respond_to(*expect_methods)
+          end
+
+          it 'reports that the syntax is :should' do
+            expect(configured_syntax).to eq([:should])
+          end
+
+          it "does not warn about the should syntax" do
+            RSpec.should_not_receive(:deprecate)
+            Object.new.should_not_receive(:bees)
+          end
+
+          it 'is a no-op when configured a second time' do
+            Syntax.default_should_syntax_host.should_not_receive(:method_added)
+            ::RSpec::Mocks::ExampleMethods.should_not_receive(:method_undefined)
+            configure_syntax :should
+          end
+        end
+
+        context 'when configured to [:should, :expect]' do
+          before { configure_syntax [:should, :expect] }
+
+          it 'adds the should methods to every object' do
+            expect(dbl).to respond_to(*should_methods)
+          end
+
+          it 'adds `any_instance` to every class' do
+            expect(Class.new).to respond_to(*should_class_methods)
+          end
+
+          it 'adds the expect methods to the example group context' do
+            expect(self).to respond_to(*expect_methods)
+          end
+
+          it 'reports that both syntaxes are enabled' do
+            expect(configured_syntax).to eq([:should, :expect])
+          end
+
+          it "does not warn about the should syntax" do
+            expect(RSpec).not_to receive(:deprecate)
+            expect(Object.new).not_to receive(:bees)
+          end
+        end
+      end
+
+      describe "configuring rspec-mocks directly" do
+        it_behaves_like "configuring the syntax" do
+          def configure_syntax(syntax)
+            RSpec::Mocks.configuration.syntax = syntax
+          end
+
+          def configured_syntax
+            RSpec::Mocks.configuration.syntax
+          end
+
+          def configure_default_syntax
+            RSpec::Mocks.configuration.reset_syntaxes_to_default
+          end
+        end
+      end
+
+      describe "configuring using the rspec-core config API" do
+        it_behaves_like "configuring the syntax" do
+          def configure_syntax(syntax)
+            RSpec.configure do |rspec|
+              rspec.mock_with :rspec do |c|
+                c.syntax = syntax
+              end
+            end
+          end
+
+          def configured_syntax
+            RSpec.configure do |rspec|
+              rspec.mock_with :rspec do |c|
+                return c.syntax
+              end
+            end
+          end
+
+          def configure_default_syntax
+            RSpec.configure do |rspec|
+              rspec.mock_with :rspec do |c|
+                c.reset_syntaxes_to_default
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end