opal-rspec 0.6.2 → 0.7.0.rc.1

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

@@ -1,113 +0,0 @@
-module RSpec
-  module Mocks
-    RSpec.describe "at_most" do
-      before(:each) do
-        @double = double
-      end
-
-      it "passes when at_most(n) is called exactly n times" do
-        expect(@double).to receive(:do_something).at_most(2).times
-        @double.do_something
-        @double.do_something
-        verify @double
-      end
-
-      it "passes when at_most(n) is called less than n times" do
-        expect(@double).to receive(:do_something).at_most(2).times
-        @double.do_something
-        verify @double
-      end
-
-      it "passes when at_most(n) is never called" do
-        expect(@double).to receive(:do_something).at_most(2).times
-        verify @double
-      end
-
-      it "passes when at_most(:once) is called once" do
-        expect(@double).to receive(:do_something).at_most(:once)
-        @double.do_something
-        verify @double
-      end
-
-      it "passes when at_most(:once) is never called" do
-        expect(@double).to receive(:do_something).at_most(:once)
-        verify @double
-      end
-
-      it "passes when at_most(:twice) is called once" do
-        expect(@double).to receive(:do_something).at_most(:twice)
-        @double.do_something
-        verify @double
-      end
-
-      it "passes when at_most(:twice) is called twice" do
-        expect(@double).to receive(:do_something).at_most(:twice)
-        @double.do_something
-        @double.do_something
-        verify @double
-      end
-
-      it "passes when at_most(:twice) is never called" do
-        expect(@double).to receive(:do_something).at_most(:twice)
-        verify @double
-      end
-
-      it "passes when at_most(:thrice) is called less than three times" do
-        expect(@double).to receive(:do_something).at_most(:thrice)
-        @double.do_something
-        verify @double
-      end
-
-      it "passes when at_most(:thrice) is called thrice" do
-        expect(@double).to receive(:do_something).at_most(:thrice)
-        @double.do_something
-        @double.do_something
-        @double.do_something
-        verify @double
-      end
-
-      it "returns the value given by a block when at_most(:once) method is called" do
-        expect(@double).to receive(:to_s).at_most(:once) { "testing" }
-        expect(@double.to_s).to eq "testing"
-        verify @double
-      end
-
-      it "fails fast when at_most(n) times method is called n plus 1 times" do
-        expect(@double).to receive(:do_something).at_most(2).times
-        @double.do_something
-        @double.do_something
-        expect {
-          @double.do_something
-        }.to raise_error(/expected: at most 2 times.*received: 3 times/m)
-      end
-
-      it "fails fast when at_most(:once) and is called twice" do
-        expect(@double).to receive(:do_something).at_most(:once)
-        @double.do_something
-        expect {
-          @double.do_something
-        }.to raise_error(/expected: at most 1 time.*received: 2 times/m)
-      end
-
-      it "fails fast when at_most(:twice) and is called three times" do
-        expect(@double).to receive(:do_something).at_most(:twice)
-        @double.do_something
-        @double.do_something
-        expect {
-          @double.do_something
-        }.to raise_error(/expected: at most 2 times.*received: 3 times/m)
-      end
-
-      it "fails fast when at_most(:thrice) and is called four times" do
-        expect(@double).to receive(:do_something).at_most(:thrice)
-        @double.do_something
-        @double.do_something
-        @double.do_something
-        expect {
-          @double.do_something
-        }.to raise_error(/expected: at most 3 times.*received: 4 times/m)
-      end
-
-    end
-  end
-end

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

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

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

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