Added optional/soft expectations

Author: ryanplusplus

mock.lua

@@ -14,10 +14,11 @@ end
 
 ExpectedCall = {}
 
-function ExpectedCall:new(f, args)
+function ExpectedCall:new(f, required, args)
   local o = {
     _f = f,
     _ordered = false,
+    _required = required,
     _args = args,
     _return = {}
   }
@@ -58,6 +59,10 @@ function ExpectedCall:hasFixedOrder()
   return self._ordered
 end
 
+function ExpectedCall:isRequired()
+  return self._required
+end
+
 MockExpectation = {}
 
 function MockExpectation:new(m)
@@ -118,7 +123,11 @@ function MockExpectation:when(thunk)
 
   mockHandle(called, thunk)
 
-  assert(#self._calls == 0, 'not all calls occurred')
+  for _, call in pairs(self._calls) do
+    if call:isRequired() then
+      error('not all calls occurred', 2)
+    end
+  end
 end
 
 function MockExpectation:after(thunk)
@@ -153,7 +162,7 @@ function MockExpectation:shouldBeCalledWith(...)
   end
 
   self._callSpecified = true
-  table.insert(self._calls, ExpectedCall:new(self._m, table.pack(...)))
+  table.insert(self._calls, ExpectedCall:new(self._m, true, table.pack(...)))
   return self
 end
 
@@ -165,6 +174,24 @@ function MockExpectation:shouldBeCalled()
   return self:shouldBeCalledWith()
 end
 
+function MockExpectation:mayBeCalledWith(...)
+  if self._callSpecified == true then
+    error('call already specified', 2)
+  end
+
+  self._callSpecified = true
+  table.insert(self._calls, ExpectedCall:new(self._m, false, table.pack(...)))
+  return self
+end
+
+function MockExpectation:mayBeCalled()
+  if self._callSpecified == true then
+    error('call already specified', 2)
+  end
+
+  return self:mayBeCalledWith()
+end
+
 function MockExpectation:multipleTimes(times)
   for i = 1, times - 1 do
     table.insert(self._calls, self._calls[#self._calls])

spec/mock_spec.lua

@@ -276,11 +276,11 @@ describe('The mock library', function()
     end)
   end)
 
-  it('should fail if shouldBeCalled is used after a call has already been specified', function()
+  it('should fail if shouldBeCalledWith is used after a call has already been specified', function()
     shouldFailWith('call already specified', function()
       local f = mock:mockFunction('f')
 
-      mock(f):shouldBeCalled():shouldBeCalledWith()
+      mock(f):shouldBeCalled():shouldBeCalledWith(4)
     end)
   end)
 
@@ -358,5 +358,67 @@ describe('The mock library', function()
     end)
   end)
 
-  -- may be called? ie: calls that are not required
+  it('should allow soft expectations to be called', function()
+    local f = mock:mockFunction('f')
+
+    mock(f):mayBeCalled():
+    when(function()
+      f()
+    end)
+  end)
+
+  it('should allow soft expectations to be omitted', function()
+    local f = mock:mockFunction('f')
+
+    mock(f):mayBeCalled():
+    when(function() end)
+  end)
+
+  it('should allow soft expectations with return values', function()
+    local f = mock:mockFunction('f')
+
+    mock(f):mayBeCalled():andWillReturn(3):
+    when(function()
+      assert(f() == 3)
+    end)
+  end)
+
+  it('should allow soft expectations with arguments to be called', function()
+    local f = mock:mockFunction('f')
+
+    mock(f):mayBeCalledWith(4):
+    when(function()
+      f(4)
+    end)
+  end)
+
+  it('should allow soft expectations with arguments to be omitted', function()
+    local f = mock:mockFunction('f')
+
+    mock(f):mayBeCalledWith(4):
+    when(function() end)
+  end)
+
+  it('should allow soft expectations with arguments to be omitted', function()
+    local f = mock:mockFunction('f')
+
+    mock(f):mayBeCalledWith(4):
+    when(function() end)
+  end)
+
+  it('should fail if mayBeCalled is used after a call has already been specified', function()
+    shouldFailWith('call already specified', function()
+      local f = mock:mockFunction('f')
+
+      mock(f):shouldBeCalled():mayBeCalled()
+    end)
+  end)
+
+  it('should fail if mayBeCalledWith is used after a call has already been specified', function()
+    shouldFailWith('call already specified', function()
+      local f = mock:mockFunction('f')
+
+      mock(f):shouldBeCalled():mayBeCalledWith(4)
+    end)
+  end)
 end)