verifying ordering of spies

lib/rspec/mocks/matchers/have_received.rb

@@ -86,7 +86,7 @@ def generate_failure_message
 
         def expected_messages_received?
           mock_proxy.replay_received_message_on @expectation, &@block
-          @expectation.expected_messages_received?
+          @expectation.expected_messages_received? && @expectation.expected_ordering_received?
         end
 
         def mock_proxy

lib/rspec/mocks/message_expectation.rb

@@ -279,6 +279,10 @@ def expected_messages_received?
         ignoring_args? || matches_exact_count? || matches_at_least_count? || matches_at_most_count?
       end
 
+      def expected_ordering_received?
+        !@ordered || @order_group.verify_invocation_order(self)
+      end
+
       # @private
       def ignoring_args?
         @expected_received_count == :any

lib/rspec/mocks/order_group.rb

@@ -36,6 +36,11 @@ def handle_order_constraint(expectation)
         expectation.raise_out_of_order_error
       end
 
+      def verify_invocation_order(expectation)
+        expectation.raise_out_of_order_error unless expectations_invoked_in_order?
+        true
+      end
+
       def clear
         @index = 0
         @invocation_order.clear
@@ -52,6 +57,22 @@ def first_ordered
         (@expectations[@index..-1] || []).find { |expectation| expectation.ordered? }
       end
 
+      def expectations_invoked_in_order?
+        invoked_expectations == expected_invocations
+      end
+
+      def invoked_expectations
+        @expectations.select { |e| e.ordered? && @invocation_order.include?([e.orig_object,e.message]) }
+      end
+
+      def expected_invocations
+        @invocation_order.map { |invocation| expectation_for(*invocation) }.compact
+      end
+
+      def expectation_for(object, message)
+        @expectations.find { |e| e.orig_object == object && e.message == message }
+      end
+
     end
   end
 end

spec/rspec/mocks/matchers/have_received_spec.rb

@@ -247,6 +247,28 @@ module Mocks
             end
           end
         end
+
+        context 'ordered' do
+          let(:dbl) { double :one => 1, :two => 2 }
+
+          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 '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
+        end
       end
 
       describe "expect(...).not_to have_received" do