Initial messy implementation

Author: ryanplusplus

firstpass.lua

@@ -0,0 +1,93 @@
+local expectation
+
+local function mock(m)
+  expectation.fn = m
+  return expectation
+end
+
+expectation = {
+  expected_calls = {},
+
+  call_count = 0,
+
+  ordered = false,
+
+  should_be_called_with = function(...)
+    expectation.expected_calls[#expectation.expected_calls + 1] = {
+      fn = expectation.fn,
+      args = table.pack(...),
+      ordered = expectation.ordered
+    }
+    expectation.fn = nil
+    expectation.ordered = false
+    return expectation
+  end,
+
+  should_be_called = function()
+    return expectation.should_be_called_with()
+  end,
+
+  and_then = function(expectation)
+    -- do some jazz where the expectations are combined? with order!
+    expectation.ordered = true
+    return expectation
+  end,
+
+  mock = mock,
+
+  check = function()
+    assert(#expectation.expected_calls == expectation.call_count)
+  end,
+
+  when = function(f)
+    f()
+    expectation.check()
+  end,
+
+  after = function(...)
+    return expectation.when(...)
+  end,
+
+  args_same = function(t1, t2)
+    if #t1 ~= #t2 then return false end
+
+    for k in ipairs(t1) do
+      if t2[k] ~= t1[k] then return false end
+    end
+
+    return true
+  end,
+
+  mock_was_called = function(m, args)
+    assert(#expectation.expected_calls > 0)
+
+    expectation.call_count = expectation.call_count + 1
+
+    assert(expectation.expected_calls[expectation.call_count].fn == m)
+    assert(expectation.args_same(expectation.expected_calls[expectation.call_count].args, args))
+  end
+}
+
+local function m1(...)
+  expectation.mock_was_called(m1, table.pack(...))
+end
+
+local function m2(...)
+  expectation.mock_was_called(m2, table.pack(...))
+end
+
+local function m1_should_be_called()
+  return mock(m1).should_be_called()
+end
+
+local function m2_should_you_know()
+  return mock(m2).should_be_called_with(1, 2, 3)
+end
+
+-- m1_should_be_called().
+-- and_then(m2_should_you_know()).
+-- after(function() m1(); m2(1, 2, 3) end)
+
+mock(m1).should_be_called().
+and_then(mock(m2).should_be_called_with(1, 2, 3)).
+when(function() m1(); m2(1, 2, 3) end)

moq.lua

@@ -0,0 +1,177 @@
+local subscriber
+
+local function mock_handle(callback, thunk)
+  subscriber = callback
+  thunk()
+  subscriber = nil
+end
+
+local function mock_called(m, args)
+  return subscriber(m, args)
+end
+
+
+
+ExpectedCall = {}
+
+function ExpectedCall:new(f, args)
+  local o = {
+    _f = f,
+    _args = args,
+    _return = {}
+  }
+
+  self.__index = self
+  setmetatable(o, self)
+
+  return o
+end
+
+function ExpectedCall:functionMatches(f)
+  return _f == self.f
+end
+
+function ExpectedCall:argsMatch(args)
+  if #self._args ~= #args then return false end
+
+  for k in ipairs(self._args) do
+    if self._args[k] ~= args[k] then return false end
+  end
+
+  return true
+end
+
+function ExpectedCall:setReturnValues(...)
+  self._return = table.pack(...)
+end
+
+function ExpectedCall:getReturnValues(...)
+  return table.unpack(self._return)
+end
+
+
+
+MockExpectation = {}
+
+function MockExpectation:new(m)
+  local o = {
+    _m = m,
+    _calls = {}
+  }
+
+  self.__index = self
+  setmetatable(o, self)
+
+  return o
+end
+
+function MockExpectation:andWillReturn(...)
+  self._calls[#self._calls]:setReturnValues(...)
+  return self
+end
+
+function MockExpectation:when(thunk)
+  local function called(m, args)
+    assert(#self._calls > 0, 'unexpected call')
+
+    assert(self._calls[1]:functionMatches(m), 'unexpected function called')
+    assert(self._calls[1]:argsMatch(args), 'unexpected arguments provided')
+
+    return table.remove(self._calls, 1):getReturnValues()
+  end
+
+  mock_handle(called, thunk)
+
+  assert(#self._calls == 0, 'not all calls occurred')
+end
+
+function MockExpectation:after(thunk)
+  self:when(thunk)
+end
+
+function MockExpectation:andThen(other)
+  -- Need to handle ordering
+  for _, call in ipairs(other._calls) do
+    table.insert(self._calls, call)
+  end
+
+  return self
+end
+
+function MockExpectation:andAlso(other)
+  -- Need to handle ordering
+  for _, call in ipairs(other._calls) do
+    table.insert(self._calls, call)
+  end
+
+  return self
+end
+
+function MockExpectation:shouldBeCalledWith(...)
+  table.insert(self._calls, ExpectedCall:new(self._m, table.pack(...)))
+  return self
+end
+
+function MockExpectation:shouldBeCalled()
+  return self:shouldBeCalledWith()
+end
+
+
+
+local function mock(m)
+  return MockExpectation:new(m)
+end
+
+local function createMockFunction()
+  local f
+
+  function f(...)
+    return mock_called(f, table.pack(...))
+  end
+
+  return f
+end
+
+local function createMockMethod()
+  local m
+
+  function m(...)
+    local args = table.pack(...)
+    table.remove(args, 1)
+    return mock_called(m, args)
+  end
+
+  return m
+end
+
+local function createMockTable(t)
+  local mocked = {}
+
+  for k, v in pairs(t) do
+    if type(v) == 'function' then
+      mocked[k] = createMockFunction()
+    end
+  end
+
+  return mocked
+end
+
+local function createMockObject(o)
+  local mocked = {}
+
+  for k, v in pairs(o) do
+    if type(v) == 'function' then
+      mocked[k] = createMockMethod()
+    end
+  end
+
+  return mocked
+end
+
+return {
+  mock = mock,
+  createMockFunction = createMockFunction,
+  createMockTable = createMockTable,
+  createMockMethod = createMockMethod,
+  createMockObject = createMockObject
+}

notes

@@ -0,0 +1,74 @@
+describe('The mock library', function()
+  moq = require 'moq'
+
+  it('should work', function()
+    local m1 = moq.createMockFunction()
+    local m2 = moq.createMockFunction()
+
+    moq.mock(m1):shouldBeCalled():
+    andAlso(moq.mock(m2):shouldBeCalledWith(1, 2, 3)):
+    andThen(moq.mock(m2):shouldBeCalledWith(1):andWillReturn(4)):
+    when(function()
+      m1()
+      m2(1, 2, 3)
+      assert.is.equal(m2(1), 4)
+    end)
+  end)
+
+  it('should allow functions to be used to improve readability', function()
+    local m1 = moq.createMockFunction()
+    local m2 = moq.createMockFunction()
+
+    function somethingShouldHappen()
+      return moq.mock(m1):shouldBeCalled()
+    end
+
+    function anotherThingShouldHappen()
+      return moq.mock(m2):shouldBeCalledWith(1, 2, 3)
+    end
+
+    function yetAnotherThingShouldHappen()
+      return moq.mock(m2):shouldBeCalledWith(1):andWillReturn(4)
+    end
+
+    function codeUnderTestRuns()
+      m1()
+      m2(1, 2, 3)
+      assert.is.equal(m2(1), 4)
+    end
+
+    somethingShouldHappen():
+    andAlso(anotherThingShouldHappen()):
+    andThen(yetAnotherThingShouldHappen()):
+    when(codeUnderTestRuns)
+  end)
+
+  it('should allow a table of functions to be mocked', function()
+    local someTable = {
+      foo = function() end,
+      bar = function() end
+    }
+
+    mockedTable = moq.createMockTable(someTable)
+
+    moq.mock(mockedTable.foo):shouldBeCalledWith(1):andWillReturn(2):
+    when(function() mockedTable.foo(1) end)
+  end)
+
+  it('should allow an object with methods to be mocked', function()
+    local someObject = {}
+
+    function someObject:foo()
+    end
+
+    function someObject:bar()
+    end
+
+    mockedObject = moq.createMockObject(someObject)
+
+    moq.mock(mockedObject.foo):shouldBeCalledWith(1):andWillReturn(2):
+    when(function() mockedObject:foo(1) end)
+  end)
+
+  -- multiple return values
+end)