Ensure that optional calls and strictly ordered calls play nicely together. Closes #12.

Author: ryanplusplus

rockspecs/mach-git-0.rockspec

@@ -19,5 +19,6 @@ build = {
     ['mach.ExpectedCall'] = 'mach/ExpectedCall.lua',
     ['mach.unexpected_call_error'] = 'mach/unexpected_call_error.lua',
     ['mach.unexpected_args_error'] = 'mach/unexpected_args_error.lua',
+    ['mach.out_of_order_call_error'] = 'mach/out_of_order_call_error.lua',
   }
 }

spec/mach_spec.lua

@@ -345,7 +345,7 @@ describe('The mach library', function()
   end)
 
   it('should not allow calls to happen out of order when and_then is used', function()
-    should_fail_with('unexpected function call f2()', function()
+    should_fail_with('out of order function call f2()', function()
       f1:should_be_called():
         and_then(f2:should_be_called()):
         when(function()
@@ -365,7 +365,7 @@ describe('The mach library', function()
   end)
 
   it('should catch out of order calls when mixed with unordered calls', function()
-    should_fail_with('unexpected function call f3()', function()
+    should_fail_with('out of order function call f3()', function()
       f1:should_be_called():
         and_also(f2:should_be_called()):
         and_then(f3:should_be_called()):
@@ -390,6 +390,21 @@ describe('The mach library', function()
       end)
   end)
 
+  it('should allow a strictly ordered call to occur after a missing optional call', function()
+    f1:may_be_called():and_then(f2:should_be_called()):when(function()
+      f2()
+    end)
+  end)
+
+  it('should not allow order to be violated for an optional call', function()
+    should_fail_with('unexpected function call f1()', function()
+      f1:may_be_called():and_then(f2:should_be_called()):when(function()
+        f2()
+        f1()
+      end)
+    end)
+  end)
+
   it('should allow soft expectations to be called', function()
     f:may_be_called():when(function() f() end)
   end)

src/mach/Expectation.lua

@@ -1,6 +1,7 @@
 local ExpectedCall = require 'mach.ExpectedCall'
 local unexpected_call_error = require 'mach.unexpected_call_error'
 local unexpected_args_error = require 'mach.unexpected_args_error'
+local out_of_order_call_error = require 'mach.out_of_order_call_error'
 
 local expectation = {}
 expectation.__index = expectation
@@ -42,16 +43,25 @@ function expectation:when(thunk)
     error('incomplete expectation', 2)
   end
 
+  local current = 1
+
   local function called(m, name, args)
     local valid_function_found = false
+    local incomplete_expectation_found = false
+
+    for i = current, #self._calls do
+      local call = self._calls[i]
 
-    for i, call in ipairs(self._calls) do
       if call:function_matches(m) then
         valid_function_found = true
 
         if call:args_match(args) then
-          if call:has_fixed_order() and i > 1 then
-            self._calls[i - 1]:fix_order()
+          if call:has_fixed_order() and incomplete_expectation_found then
+            out_of_order_call_error(name, args, 2)
+          end
+
+          if call:has_fixed_order() then
+            current = i
           end
 
           table.remove(self._calls, i)
@@ -64,7 +74,9 @@ function expectation:when(thunk)
         end
       end
 
-      if call:has_fixed_order() then break end
+      if call:is_required() then
+        incomplete_expectation_found = true;
+      end
     end
 
     if not self._ignore_other_calls then
@@ -94,9 +106,8 @@ function expectation:after(thunk)
 end
 
 function expectation:and_then(other)
-  self._calls[#self._calls]:fix_order()
-
   for _, call in ipairs(other._calls) do
+    call:fix_order()
     table.insert(self._calls, call)
   end
 

src/mach/out_of_order_call_error.lua

@@ -0,0 +1,8 @@
+return function(name, args, level)
+  local arg_strings = {}
+  for _, arg in ipairs(args) do
+    table.insert(arg_strings, tostring(arg))
+  end
+
+  error('out of order function call ' .. name .. '(' .. table.concat(arg_strings, ', ') .. ')', level + 1)
+end