opal-rspec 0.6.2 → 0.7.0.rc.1

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

@@ -1,11 +0,0 @@
-module RSpec
-  module Mocks
-    RSpec.describe ExampleMethods do
-      it 'does not define private helper methods since it gets included into a ' +
-         'namespace where users define methods and could inadvertently overwrite ' +
-         'them' do
-        expect(ExampleMethods.private_instance_methods).to eq([])
-      end
-    end
-  end
-end

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

@@ -1,90 +0,0 @@
-module RSpec
-  module Mocks
-    RSpec.describe "After a test double has been torn down" do
-      RSpec.shared_examples_for "expiration" do
-        before do
-          expect(dbl).to receive(:foo).at_least(:once)
-          allow(dbl).to receive(:bar)
-          dbl.foo
-
-          RSpec::Mocks.verify
-          RSpec::Mocks.teardown
-          RSpec::Mocks.setup
-        end
-
-        it 'disallows previously mocked methods' do
-          expect { dbl.foo }.to raise_error(ExpiredTestDoubleError)
-        end
-
-        it 'disallows previously stubbed methods' do
-          expect { dbl.bar }.to raise_error(ExpiredTestDoubleError)
-        end
-
-        it 'disallows stubbing new methods (with receive)' do
-          expect {
-            allow(dbl).to receive(:bazz)
-          }.to raise_error(ExpiredTestDoubleError)
-        end
-
-        it 'disallows stubbing new methods (with receive_messages)' do
-          expect {
-            allow(dbl).to receive_messages(:bazz => 3)
-          }.to raise_error(ExpiredTestDoubleError)
-        end
-
-        it 'disallows stubbing new message chains' do
-          expect {
-            allow(dbl).to receive_message_chain(:bazz, :bam, :goo)
-          }.to raise_error(ExpiredTestDoubleError)
-        end
-
-        it 'disallows mocking new methods' do
-          expect {
-            expect(dbl).to receive(:bazz)
-          }.to raise_error(ExpiredTestDoubleError)
-        end
-
-        it 'disallows being turned into a null object' do
-          expect { dbl.as_null_object }.to raise_error(ExpiredTestDoubleError)
-        end
-
-        it 'disallows being checked for nullness' do
-          expect { dbl.null_object? }.to raise_error(ExpiredTestDoubleError)
-        end
-
-      end
-
-      context "for a plain double" do
-        let(:dbl) { double }
-        include_examples "expiration"
-      end
-
-      class ExpiredInstanceInterface
-        def foo;  end
-        def bar;  end
-        def bazz; end
-      end
-
-      class ExpiredClassInterface
-        def self.foo;  end
-        def self.bar;  end
-        def self.bazz; end
-      end
-
-      context "for an instance_double" do
-        let(:dbl) { instance_double(ExpiredInstanceInterface) }
-        include_examples "expiration"
-      end
-
-      context "for a class_double" do
-        let(:dbl) { class_double(ExpiredClassInterface) }
-        include_examples "expiration"
-      end
-
-      context "for an object_double" do
-        let(:dbl) { object_double(ExpiredInstanceInterface.new) }
-        include_examples "expiration"
-      end
-    end
-  end
-end

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

@@ -1,65 +0,0 @@
-module RSpec
-  module Mocks
-    module ArgumentMatchers
-      RSpec.describe HashExcludingMatcher do
-
-        it "describes itself properly" do
-          expect(HashExcludingMatcher.new(:a => 5).description).to eq "hash_not_including(:a=>5)"
-        end
-
-        describe "passing" do
-          it "matches a hash without the specified key" do
-            expect(hash_not_including(:c)).to be === {:a => 1, :b => 2}
-          end
-
-          it "matches a hash with the specified key, but different value" do
-            expect(hash_not_including(:b => 3)).to be === {:a => 1, :b => 2}
-          end
-
-          it "matches a hash without the specified key, given as anything()" do
-            expect(hash_not_including(:c => anything)).to be === {:a => 1, :b => 2}
-          end
-
-          it "matches an empty hash" do
-            expect(hash_not_including(:a)).to be === {}
-          end
-
-          it "matches a hash without any of the specified keys" do
-            expect(hash_not_including(:a, :b, :c)).to be === { :d => 7 }
-          end
-
-        end
-
-        describe "failing" do
-          it "does not match a non-hash" do
-            expect(hash_not_including(:a => 1)).not_to be === 1
-          end
-
-          it "does not match a hash with a specified key" do
-            expect(hash_not_including(:b)).not_to be === { :b => 2 }
-          end
-
-          it "does not match a hash with the specified key/value pair" do
-            expect(hash_not_including(:b => 2)).not_to be === { :a => 1, :b => 2 }
-          end
-
-          it "does not match a hash with the specified key" do
-            expect(hash_not_including(:a, :b => 3)).not_to be === { :a => 1, :b => 2 }
-          end
-
-          it "does not match a hash with one of the specified keys" do
-            expect(hash_not_including(:a, :b)).not_to be === { :b => 2 }
-          end
-
-          it "does not match a hash with some of the specified keys" do
-            expect(hash_not_including(:a, :b, :c)).not_to be === { :a => 1, :b => 2 }
-          end
-
-          it "does not match a hash with one key/value pair included" do
-            expect(hash_not_including(:a, :b, :c, :d => 7)).not_to be === { :d => 7 }
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,92 +0,0 @@
-module RSpec
-  module Mocks
-    module ArgumentMatchers
-      RSpec.describe HashIncludingMatcher do
-
-        it "describes itself properly" do
-          expect(HashIncludingMatcher.new(:a => 1).description).to eq "hash_including(:a=>1)"
-        end
-
-        describe "passing" do
-          it "matches the same hash" do
-            expect(hash_including(:a => 1)).to be === {:a => 1}
-          end
-
-          it "matches a hash with extra stuff" do
-            expect(hash_including(:a => 1)).to be === {:a => 1, :b => 2}
-          end
-
-          describe "when matching against other matchers" do
-            it "matches an int against anything()" do
-              expect(hash_including(:a => anything, :b => 2)).to be === {:a => 1, :b => 2}
-            end
-
-            it "matches a string against anything()" do
-              expect(hash_including(:a => anything, :b => 2)).to be === {:a => "1", :b => 2}
-            end
-
-            it 'can match against arbitrary objects that implement #===' do
-              expect(hash_including(:a => /foo/)).to be === { :a => "foobar" }
-            end
-          end
-
-          describe "when passed only keys or keys mixed with key/value pairs" do
-            it "matches if the key is present" do
-              expect(hash_including(:a)).to be === {:a => 1, :b => 2}
-            end
-
-            it "matches if more keys are present" do
-              expect(hash_including(:a, :b)).to be === {:a => 1, :b => 2, :c => 3}
-            end
-
-            it "matches a string against a given key" do
-              expect(hash_including(:a)).to be === {:a => "1", :b => 2}
-            end
-
-            it "matches if passed one key and one key/value pair" do
-              expect(hash_including(:a, :b => 2)).to be === {:a => 1, :b => 2}
-            end
-
-            it "matches if passed many keys and one key/value pair" do
-              expect(hash_including(:a, :b, :c => 3)).to be === {:a => 1, :b => 2, :c => 3, :d => 4}
-            end
-
-            it "matches if passed many keys and many key/value pairs" do
-              expect(hash_including(:a, :b, :c => 3, :e => 5)).to be === {:a => 1, :b => 2, :c => 3, :d => 4, :e => 5}
-            end
-          end
-        end
-
-        describe "failing" do
-          it "does not match a non-hash" do
-            expect(hash_including(:a => 1)).not_to be === 1
-          end
-
-          it "does not match a hash with a missing key" do
-            expect(hash_including(:a => 1)).not_to be === { :b => 2 }
-          end
-
-          it "does not match a hash with a missing key" do
-            expect(hash_including(:a)).not_to be === { :b => 2 }
-          end
-
-          it "does not match an empty hash with a given key" do
-            expect(hash_including(:a)).not_to be === {}
-          end
-
-          it "does not match a hash with a missing key when one pair is matching" do
-            expect(hash_including(:a, :b => 2)).not_to be === { :b => 2 }
-          end
-
-          it "does not match a hash with an incorrect value" do
-            expect(hash_including(:a => 1, :b => 2)).not_to be === { :a => 1, :b => 3 }
-          end
-
-          it "does not match when values are nil but keys are different" do
-            expect(hash_including(:a => nil)).not_to be === { :b => nil }
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,72 +0,0 @@
-module RSpec
-  module Mocks
-    RSpec.describe InstanceMethodStasher do
-      class ExampleClass
-        def hello
-          :hello_defined_on_class
-        end
-      end
-
-      def singleton_class_for(obj)
-        class << obj; self; end
-      end
-
-      def stasher_for(obj, method_name)
-        InstanceMethodStasher.new(obj, method_name)
-      end
-
-      it "stashes the current implementation of an instance method so it can be temporarily replaced" do
-        obj = Object.new
-        def obj.hello; :hello_defined_on_singleton_class; end;
-
-        stashed_method = stasher_for(obj, :hello)
-        stashed_method.stash
-
-        with_isolated_stderr { def obj.hello; :overridden_hello; end }
-        expect(obj.hello).to eql :overridden_hello
-
-        stashed_method.restore
-        expect(obj.hello).to eql :hello_defined_on_singleton_class
-      end
-
-      it "stashes private instance methods" do
-        obj = Object.new
-        def obj.hello; :hello_defined_on_singleton_class; end;
-        singleton_class_for(obj).__send__(:private, :hello)
-
-        stashed_method = stasher_for(obj, :hello)
-        stashed_method.stash
-
-        with_isolated_stderr { def obj.hello; :overridden_hello; end }
-        stashed_method.restore
-        expect(obj.send(:hello)).to eql :hello_defined_on_singleton_class
-      end
-
-      it "only stashes methods directly defined on the given class, not its ancestors" do
-        obj = ExampleClass.new
-
-        stashed_method = stasher_for(obj, :hello)
-        stashed_method.stash
-
-        def obj.hello; :overridden_hello; end;
-        expect(obj.hello).to eql :overridden_hello
-
-        stashed_method.restore
-        expect(obj.hello).to eql :overridden_hello
-      end
-
-      it "does not unnecessarily create obfuscated aliased methods", :if => (RUBY_VERSION.to_f > 1.8) do
-        obj = Object.new
-        def obj.hello; :hello_defined_on_singleton_class; end;
-
-        stashed_method = stasher_for(obj, :hello)
-
-        expect {
-          stashed_method.stash
-        }.not_to change { obj.methods.count }
-
-        expect(obj.methods.grep(/rspec/)).to eq([])
-      end
-    end
-  end
-end

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

@@ -1,67 +0,0 @@
-RSpec.describe Marshal, 'extensions' do
-  # An object that raises when code attempts to dup it.
-  #
-  # Because we manipulate the internals of RSpec::Mocks.space below, we need
-  # an object that simply blows up when #dup is called without using any
-  # partial mocking or stubbing from rspec-mocks itself.
-  class UndupableObject
-    def dup
-      raise NotImplementedError
-    end
-  end
-
-  describe '#dump' do
-    context 'when rspec-mocks has been fully initialized' do
-      include_context "with monkey-patched marshal"
-
-      it 'duplicates objects with stubbed or mocked implementations before serialization' do
-        obj = double(:foo => "bar")
-
-        serialized = Marshal.dump(obj)
-        expect(Marshal.load(serialized)).to be_an(obj.class)
-      end
-
-      it 'does not duplicate other objects before serialization' do
-        obj = UndupableObject.new
-
-        serialized = Marshal.dump(obj)
-        expect(Marshal.load(serialized)).to be_an(UndupableObject)
-      end
-
-      it 'does not duplicate nil before serialization' do
-        serialized = Marshal.dump(nil)
-        expect(Marshal.load(serialized)).to be_nil
-      end
-
-      specify 'applying and unapplying patch is idempotent' do
-        obj = double(:foo => "bar")
-        config = RSpec::Mocks.configuration
-
-        config.patch_marshal_to_support_partial_doubles = true
-        config.patch_marshal_to_support_partial_doubles = true
-        serialized = Marshal.dump(obj)
-        expect(Marshal.load(serialized)).to be_an(obj.class)
-        config.patch_marshal_to_support_partial_doubles = false
-        config.patch_marshal_to_support_partial_doubles = false
-        expect { Marshal.dump(obj) }.to raise_error(TypeError)
-      end
-    end
-
-    context 'outside the per-test lifecycle' do
-      def outside_per_test_lifecycle
-        RSpec::Mocks.teardown
-        yield
-      ensure
-        RSpec::Mocks.setup
-      end
-
-      it 'does not duplicate the object before serialization' do
-        obj = UndupableObject.new
-        outside_per_test_lifecycle do
-          serialized = Marshal.dump(obj)
-          expect(Marshal.load(serialized)).to be_an(UndupableObject)
-        end
-      end
-    end
-  end
-end

data/rspec-mocks/spec/rspec/mocks/matchers/have_received_spec.rb

@@ -1,513 +0,0 @@
-module RSpec
-  module Mocks
-    RSpec.describe Matchers::HaveReceived do
-      describe "expect(...).to have_received" do
-        it 'passes when the double has received the given message' do
-          dbl = double_with_met_expectation(:expected_method)
-          expect(dbl).to have_received(:expected_method)
-        end
-
-        it 'passes when a null object has received the given message' do
-          dbl = null_object_with_met_expectation(:expected_method)
-          expect(dbl).to have_received(:expected_method)
-        end
-
-        it 'fails when the double has not received the given message' do
-          dbl = double_with_unmet_expectation(:expected_method)
-
-          expect {
-            expect(dbl).to have_received(:expected_method)
-          }.to raise_error(/expected: 1 time/)
-        end
-
-        it 'fails when a null object has not received the given message' do
-          dbl = double.as_null_object
-
-          expect {
-            expect(dbl).to have_received(:expected_method)
-          }.to raise_error(/expected: 1 time/)
-        end
-
-        it 'fails when the method has not been previously stubbed' do
-          dbl = double
-
-          expect {
-            expect(dbl).to have_received(:expected_method)
-          }.to raise_error(/method has not been stubbed/)
-        end
-
-        it 'fails when the method has been mocked' do
-          dbl = double
-          expect(dbl).to receive(:expected_method)
-          dbl.expected_method
-
-          expect {
-            expect(dbl).to have_received(:expected_method)
-          }.to raise_error(/method has been mocked instead of stubbed/)
-        end
-
-        it "takes a curly-bracket block and yields the arguments given to the stubbed method call" do
-          dbl = double(:foo => nil)
-          yielded = []
-          dbl.foo(:a, :b, :c)
-          expect(dbl).to have_received(:foo) { |*args|
-            yielded << args
-          }
-          expect(yielded).to include([:a,:b,:c])
-        end
-
-        it "takes a do-end block and yields the arguments given to the stubbed method call" do
-          dbl = double(:foo => nil)
-          yielded = []
-          dbl.foo(:a, :b, :c)
-          expect(dbl).to have_received(:foo) do |*args|
-            yielded << args
-          end
-          expect(yielded).to include([:a,:b,:c])
-        end
-
-        it "passes if expectations against the yielded arguments pass" do
-          dbl = double(:foo => nil)
-          dbl.foo(42)
-          expect {
-            expect(dbl).to have_received(:foo) { |arg|
-              expect(arg).to eq(42)
-            }
-          }.to_not raise_error
-        end
-
-        it "fails if expectations against the yielded arguments fail" do
-          dbl = double(:foo => nil)
-          dbl.foo(43)
-          expect {
-            expect(dbl).to have_received(:foo) { |arg|
-              expect(arg).to eq(42)
-            }
-          }.to raise_error(RSpec::Expectations::ExpectationNotMetError)
-        end
-
-        it 'gives precedence to a `{ ... }` block when both forms are provided ' +
-           'since that form actually binds to `receive`' do
-          dbl = double(:foo => nil)
-          called = []
-          dbl.foo
-          expect(dbl).to have_received(:foo) { called << :curly } do
-            called << :do_end
-          end
-          expect(called).to include(:curly)
-          expect(called).not_to include(:do_end)
-        end
-
-        it 'resets expectations on class methods when mocks are reset' do
-          dbl = Object
-          allow(dbl).to receive(:expected_method)
-          dbl.expected_method
-          reset dbl
-          allow(dbl).to receive(:expected_method)
-
-          expect {
-            expect(dbl).to have_received(:expected_method)
-          }.to raise_error(/0 times/)
-        end
-
-        context "with" do
-          it 'passes when the given args match the args used with the message' do
-            dbl = double_with_met_expectation(:expected_method, :expected, :args)
-            expect(dbl).to have_received(:expected_method).with(:expected, :args)
-          end
-
-          it 'fails when the given args do not match the args used with the message' do
-            dbl = double_with_met_expectation(:expected_method, :expected, :args)
-
-            expect {
-              expect(dbl).to have_received(:expected_method).with(:unexpected, :args)
-            }.to raise_error(/with unexpected arguments/)
-          end
-        end
-
-        it 'generates a useful description' do
-          matcher = have_received(:expected_method).with(:expected_args).once
-          expect(matcher.description).to eq 'have received expected_method(:expected_args) 1 time'
-        end
-
-        it 'can generate a description after mocks have been torn down (e.g. when rspec-core requests it)' do
-          matcher = have_received(:expected_method).with(:expected_args).once
-          matcher.matches?(double(:expected_method => 1))
-          RSpec::Mocks.teardown
-          expect(matcher.description).to eq 'have received expected_method(:expected_args) 1 time'
-        end
-
-        context "counts" do
-          let(:dbl) { double(:expected_method => nil) }
-
-          before do
-            dbl.expected_method
-            dbl.expected_method
-            dbl.expected_method
-          end
-
-          context "exactly" do
-            it 'passes when the message was received the given number of times' do
-              expect(dbl).to have_received(:expected_method).exactly(3).times
-            end
-
-            it 'fails when the message was received more times than expected' do
-              expect {
-                expect(dbl).to have_received(:expected_method).exactly(1).times
-              }.to raise_error(/expected: 1 time.*received: 3 times/m)
-              expect {
-                expect(dbl).to have_received(:expected_method).exactly(2).times
-              }.to raise_error(/expected: 2 times.*received: 3 times/m)
-              expect {
-                dbl.expected_method
-                dbl.expected_method
-                expect(dbl).to have_received(:expected_method).exactly(2).times
-              }.to raise_error(/expected: 2 times.*received: 5 times/m)
-            end
-
-            it 'fails when the message was received fewer times' do
-              expect {
-                expect(dbl).to have_received(:expected_method).exactly(4).times
-              }.to raise_error(/expected: 4 times.*received: 3 times/m)
-            end
-          end
-
-          context 'at_least' do
-            it 'passes when the message was received the given number of times' do
-              expect(dbl).to have_received(:expected_method).at_least(3).times
-            end
-
-            it 'passes when the message was received more times' do
-              expect(dbl).to have_received(:expected_method).at_least(2).times
-            end
-
-            it 'fails when the message was received fewer times' do
-              expect {
-                expect(dbl).to have_received(:expected_method).at_least(4).times
-              }.to raise_error(/expected: at least 4 times.*received: 3 times/m)
-            end
-          end
-
-          context 'at_most' do
-            it 'passes when the message was received the given number of times' do
-              expect(dbl).to have_received(:expected_method).at_most(3).times
-            end
-
-            it 'passes when the message was received fewer times' do
-              expect(dbl).to have_received(:expected_method).at_most(4).times
-            end
-
-            it 'fails when the message was received more times' do
-              expect {
-                expect(dbl).to have_received(:expected_method).at_most(2).times
-              }.to raise_error(/expected: at most 2 times.*received: 3 times/m)
-            end
-          end
-
-          context 'once' do
-            it 'passes when the message was received once' do
-              dbl = double(:expected_method => nil)
-              dbl.expected_method
-              expect(dbl).to have_received(:expected_method).once
-            end
-
-            it 'fails when the message was never received' do
-              dbl = double(:expected_method => nil)
-
-              expect {
-                expect(dbl).to have_received(:expected_method).once
-              }.to raise_error(/expected: 1 time.*received: 0 times/m)
-            end
-
-            it 'fails when the message was received twice' do
-              dbl = double(:expected_method => nil)
-              dbl.expected_method
-              dbl.expected_method
-
-              expect {
-                expect(dbl).to have_received(:expected_method).once
-              }.to raise_error(/expected: 1 time.*received: 2 times/m)
-            end
-          end
-
-          context 'twice' do
-            it 'passes when the message was received twice' do
-              dbl = double(:expected_method => nil)
-              dbl.expected_method
-              dbl.expected_method
-
-              expect(dbl).to have_received(:expected_method).twice
-            end
-
-            it 'fails when the message was received once' do
-              dbl = double(:expected_method => nil)
-              dbl.expected_method
-
-              expect {
-                expect(dbl).to have_received(:expected_method).twice
-              }.to raise_error(/expected: 2 times.*received: 1 time/m)
-            end
-
-            it 'fails when the message was received thrice' do
-              dbl = double(:expected_method => nil)
-              dbl.expected_method
-              dbl.expected_method
-              dbl.expected_method
-
-              expect {
-                expect(dbl).to have_received(:expected_method).twice
-              }.to raise_error(/expected: 2 times.*received: 3 times/m)
-            end
-          end
-
-          context 'thrice' do
-            it 'passes when the message was received thrice' do
-              dbl = double(:expected_method => nil)
-              dbl.expected_method
-              dbl.expected_method
-              dbl.expected_method
-
-              expect(dbl).to have_received(:expected_method).thrice
-            end
-
-            it 'fails when the message was received less than three times' do
-              dbl = double(:expected_method => nil)
-              dbl.expected_method
-              dbl.expected_method
-
-              expect {
-                expect(dbl).to have_received(:expected_method).thrice
-              }.to raise_error(/expected: 3 times.*received: 2 times/m)
-            end
-
-            it 'fails when the message was received more than three times' do
-              dbl = double(:expected_method => nil)
-              dbl.expected_method
-              dbl.expected_method
-              dbl.expected_method
-              dbl.expected_method
-
-              expect {
-                expect(dbl).to have_received(:expected_method).thrice
-              }.to raise_error(/expected: 3 times.*received: 4 times/m)
-            end
-          end
-        end
-
-        context 'ordered' do
-          let(:dbl) { double :one => 1, :two => 2, :three => 3 }
-
-          it 'passes when the messages were received in order' do
-            dbl.one
-            dbl.two
-
-            expect(dbl).to have_received(:one).ordered
-            expect(dbl).to have_received(:two).ordered
-          end
-
-          it 'passes with exact receive counts when received in order' do
-            3.times { dbl.one }
-            2.times { dbl.two }
-            dbl.three
-
-            expect(dbl).to have_received(:one).thrice.ordered
-            expect(dbl).to have_received(:two).twice.ordered
-            expect(dbl).to have_received(:three).once.ordered
-          end
-
-          pending 'passes with at most receive counts when received in order' do
-            dbl.one
-            dbl.one
-            dbl.two
-
-            expect(dbl).to have_received(:one).at_most(3).times.ordered
-            expect(dbl).to have_received(:one).at_most(:thrice).times.ordered
-            expect(dbl).to have_received(:two).once.ordered
-          end
-
-          pending 'passes with at least receive counts when received in order' do
-            dbl.one
-            dbl.one
-            dbl.two
-
-            expect(dbl).to have_received(:one).at_least(1).times.ordered
-            expect(dbl).to have_received(:two).once.ordered
-          end
-
-          it 'fails with exact receive counts when received out of order' do
-            dbl.one
-            dbl.two
-            dbl.one
-
-            expect {
-              expect(dbl).to have_received(:one).twice.ordered
-              expect(dbl).to have_received(:two).once.ordered
-            }.to raise_error(/received :two out of order/m)
-          end
-
-          pending "fails with at most receive counts when recieved out of order" do
-            dbl.one
-            dbl.two
-            dbl.one
-
-            expect {
-              expect(dbl).to have_received(:one).at_most(2).times.ordered
-              expect(dbl).to have_received(:two).once.ordered
-            }.to raise_error(/received :two out of order/m)
-          end
-
-          pending "fails with at least receive counts when recieved out of order" do
-            dbl.one
-            dbl.two
-            dbl.one
-
-            expect {
-              expect(dbl).to have_received(:one).at_least(1).times.ordered
-              expect(dbl).to have_received(:two).once.ordered
-            }.to raise_error(/received :two out of order/m)
-          end
-
-          it 'fails when the messages are received out of order' do
-            dbl.two
-            dbl.one
-
-            expect {
-              expect(dbl).to have_received(:one).ordered
-              expect(dbl).to have_received(:two).ordered
-            }.to raise_error(/received :two out of order/m)
-          end
-
-          context "when used with `with`" do
-            before do
-              dbl.one(1)
-              dbl.one(2)
-            end
-
-            it "passes when the order lines up" do
-              expect(dbl).to have_received(:one).with(1).ordered
-              expect(dbl).to have_received(:one).with(2).ordered
-            end
-
-            it "fails when the order is not matched" do
-              expect {
-                expect(dbl).to have_received(:one).with(2).ordered
-                expect(dbl).to have_received(:one).with(1).ordered
-              }.to fail_with(/received :one out of order/m)
-            end
-          end
-
-          context "when used on individually allowed messages" do
-            before do
-              allow(dbl).to receive(:foo)
-              allow(dbl).to receive(:bar)
-
-              dbl.foo
-              dbl.bar
-            end
-
-            it 'passes when the messages were received in order' do
-              expect(dbl).to have_received(:foo).ordered
-              expect(dbl).to have_received(:bar).ordered
-            end
-
-            it 'fails when the messages are received out of order' do
-              expect {
-                expect(dbl).to have_received(:bar).ordered
-                expect(dbl).to have_received(:foo).ordered
-              }.to raise_error(/received :foo out of order/m)
-            end
-          end
-        end
-      end
-
-      describe "expect(...).not_to have_received" do
-        it 'passes when the double has not received the given message' do
-          dbl = double_with_unmet_expectation(:expected_method)
-          expect(dbl).not_to have_received(:expected_method)
-        end
-
-        it 'fails when the double has received the given message' do
-          dbl = double_with_met_expectation(:expected_method)
-
-          expect {
-            expect(dbl).not_to have_received(:expected_method)
-          }.to raise_error(/expected: 0 times.*received: 1 time/m)
-        end
-
-        it 'fails when the method has not been previously stubbed' do
-          dbl = double
-
-          expect {
-            expect(dbl).not_to have_received(:expected_method)
-          }.to raise_error(/method has not been stubbed/)
-        end
-
-        context "with" do
-          it 'passes when the given args do not match the args used with the message' do
-            dbl = double_with_met_expectation(:expected_method, :expected, :args)
-            expect(dbl).not_to have_received(:expected_method).with(:unexpected, :args)
-          end
-
-          it 'fails when the given args match the args used with the message' do
-            dbl = double_with_met_expectation(:expected_method, :expected, :args)
-
-            expect {
-              expect(dbl).not_to have_received(:expected_method).with(:expected, :args)
-            }.to raise_error(/expected: 0 times.*received: 1 time/m) # TODO: better message
-          end
-        end
-
-        %w(exactly at_least at_most times once twice).each do |constraint|
-          it "does not allow #{constraint} to be used because it creates confusion" do
-            dbl = double_with_unmet_expectation(:expected_method)
-            expect {
-              expect(dbl).not_to have_received(:expected_method).send(constraint)
-            }.to raise_error(/can't use #{constraint} when negative/)
-          end
-        end
-      end
-
-      describe "allow(...).to have_received" do
-        it "fails because its nonsensical" do
-          expect {
-            allow(double).to have_received(:some_method)
-          }.to fail_with("Using allow(...) with the `have_received` matcher is not supported as it would have no effect.")
-        end
-      end
-
-      describe "allow_any_instance_of(...).to have_received" do
-        it "fails because its nonsensical" do
-          expect {
-            allow_any_instance_of(double).to have_received(:some_method)
-          }.to fail_with("Using allow_any_instance_of(...) with the `have_received` matcher is not supported.")
-        end
-      end
-
-      describe "expect_any_instance_of(...).to have_received" do
-        it "fails because we dont want to support it" do
-          expect {
-            expect_any_instance_of(double).to have_received(:some_method)
-          }.to fail_with("Using expect_any_instance_of(...) with the `have_received` matcher is not supported.")
-        end
-      end
-
-      def double_with_met_expectation(method_name, *args)
-        double = double_with_unmet_expectation(method_name)
-        meet_expectation(double, method_name, *args)
-      end
-
-      def null_object_with_met_expectation(method_name, *args)
-        meet_expectation(double.as_null_object, method_name, *args)
-      end
-
-      def meet_expectation(double, method_name, *args)
-        double.send(method_name, *args)
-        double
-      end
-
-      def double_with_unmet_expectation(method_name)
-        double('double', method_name => true)
-      end
-    end
-  end
-end