Module:UnitTests

-- UnitTester provides unit testing for other Lua scripts. For details see [[Wikipedia:Lua#Unit testing]].
-- For user documentation see above.
local UnitTester = {}

-- The cfg table contains all localisable strings and configuration, to make it
-- easier to port this module to another wiki.
local cfg = mw.loadData('Module:UnitTests/config')

local frame, tick, cross, should_highlight

local result_table = {n = 0}
local result_table_mt = {
	insert = function (self, ...)
		local n = self.n
		for i = 1, select('#', ...) do
			local val = select(i, ...)
			if val ~= nil then
				n = n + 1
				self[n] = val
			end
		end
		self.n = n
	end,
	insert_format = function (self, ...)
		self:insert(string.format(...))
	end,
	concat = table.concat
}
result_table_mt.__index = result_table_mt
setmetatable(result_table, result_table_mt)

local num_failures_sandbox = 0
local num_failures = 0
local num_runs = 0

local function first_difference(s1, s2)
	s1, s2 = tostring(s1), tostring(s2)
	if s1 == s2 then return '' end
	local max = math.min(#s1, #s2)
	for i = 1, max do
		if s1:sub(i, i) ~= s2:sub(i, i) then return i end
	end
	return max + 1
end

local function highlight_diff(str)
	if mw.ustring.find(str, "%s") then
		return '<span style="background-color: var(--wikt-palette-red-4,pink);">' ..
			string.gsub(str, " ", "&nbsp;") .. '</span>'
	else
		return '<span style="color: var(--wikt-palette-red-9, red);">' ..
			str .. '</span>'
	end
end

local is_combining = require("Module:Unicode data").is_combining


local function find_noncombining(str, i, incr)
	while true do
		local ch = mw.ustring.sub(str, i, i)
		if ch == "" or not is_combining(mw.ustring.byte(ch)) then
			return i
		end
		i = i + incr
	end
end

-- Highlight character where a difference was found. Start highlight at first
-- non-combining character before the position. End it after the first non-
-- combining characters after the position.
local function highlight_difference(actual, expected, differs_at)
	if type(differs_at) ~= "number" or not (actual and expected) then
		return actual
	end
	differs_at = find_noncombining(expected, differs_at, -1)
	local i = find_noncombining(actual, differs_at, -1)
	local j = find_noncombining(actual, differs_at + 1, 1)
	j = j - 1
	return mw.ustring.sub(actual, 1, i - 1) ..
		highlight_diff(mw.ustring.sub(actual, i, j)) ..
		mw.ustring.sub(actual, j + 1, -1)
end

local function return_varargs(...)
	return ...
end

function UnitTester:calculate_output(text, expected, actual, options)
	-- Set up some variables for throughout for ease
	num_runs = num_runs + 1
	options = options or {}

	-- Fix any stripmarkers if asked to do so to prevent incorrect fails
	local compared_expected = expected
	local compared_actual = actual
	if options.templatestyles then
		local pattern = '(\127[^\127]*UNIQ%-%-templatestyles%-)(%x+)(%-QINU[^\127]*\127)'
		local _, expected_stripmarker_id = compared_expected:match(pattern)				-- when module rendering has templatestyles strip markers, use ID from expected to prevent false test fail
		if expected_stripmarker_id then
			compared_actual = compared_actual:gsub(pattern, '%1' .. expected_stripmarker_id .. '%3')	-- replace actual id with expected id; ignore second capture in pattern
			compared_expected = compared_expected:gsub(pattern, '%1' .. expected_stripmarker_id .. '%3')		-- account for other strip markers
		end
	end
	if options.stripmarker then
		local pattern = '(\127[^\127]*UNIQ%-%-%l+%-)(%x+)(%-%-?QINU[^\127]*\127)'
		local _, expected_stripmarker_id = compared_expected:match(pattern)
		if expected_stripmarker_id then
			compared_actual = compared_actual:gsub(pattern, '%1' .. expected_stripmarker_id .. '%3')
			compared_expected = compared_expected:gsub(pattern, '%1' .. expected_stripmarker_id .. '%3')
		end
	end

	-- Perform the comparison
	local success = compared_actual == compared_expected
	if options.noexpectation and compared_expected == '' then
		success = true
	end
	if not success then
		num_failures = num_failures + 1
	end

	-- Sort the wikitext for displaying the results
	if options.combined then
		-- We need 2 rows available for the expected and actual columns
		-- Top one is parsed, bottom is unparsed
		local diff, differs_at = 0, self.differs_at and (' \n| rowspan=2|' .. first_difference(compared_expected, compared_actual)) or ''
		-- Local copies of tick/cross to allow for highlighting
		local highlight = (should_highlight and not success and 'style="background: #fc0;" ') or ''
		local highlight_diff = return_varargs
		if self.differs_at then
			diff = first_difference(compared_expected, compared_actual)
			differs_at = ' \n| rowspan=2|' .. diff
			if type(diff) == "number" then
				highlight_diff = highlight_difference
			end
		end
		result_table:insert(													-- Start output
			'| ', highlight, 'rowspan=2|', success and tick or cross,			-- Tick/Cross (2 rows)
			' \n| rowspan=2|', mw.text.nowiki(text), ' \n| ',					-- Text used for the test (2 rows)
			expected, ' \n| ', highlight_diff(actual, expected, diff),											-- The parsed outputs (in the 1st row)
			differs_at, ' \n|-\n| ',											-- Where any relevant difference was (2 rows)
			mw.text.nowiki(expected), ' \n| ', highlight_diff(mw.text.nowiki(actual), mw.text.nowiki(actual), first_difference(mw.text.nowiki(expected), mw.text.nowiki(actual))),			-- The unparsed outputs (in the 2nd row)
			'\n|-\n'															-- End output
		)
	else
		-- Display normally with whichever option was preferred (nowiki/parsed)
		local differs_at = ''
		local formatting = options.nowiki and mw.text.nowiki or return_varargs
		local highlight = (should_highlight and not success and 'style="background: #fc0;" |') or ''
		local formated_expected, formated_actual = formatting(expected), formatting(actual)
		if self.differs_at then
			local diff = first_difference(compared_expected, compared_actual)
			differs_at = ' \n| ' .. diff
			if type(diff) == "number" then
				formated_actual = highlight_difference(formated_actual, formated_expected, first_difference(formated_actual, formated_expected))
			end
		end
		result_table:insert(													-- Start output
			'| ', highlight, success and tick or cross,							-- Tick/Cross
			' \n| ', mw.text.nowiki(text), ' \n| ',								-- Text used for the test
			formated_expected, ' \n| ', formated_actual,					-- The formatted outputs
			differs_at,															-- Where any relevant difference was
			'\n|-\n'															-- End output
		)
	end
end

function UnitTester:preprocess_equals(text, expected, options)
	local actual = frame:preprocess(text)
	self:calculate_output(text, expected, actual, options)
end

function UnitTester:preprocess_equals_many(prefix, suffix, cases, options)
	for _, case in ipairs(cases) do
		self:preprocess_equals(prefix .. case[1] .. suffix, case[2], options)
	end
end

function UnitTester:preprocess_equals_preprocess(text1, text2, options)
	local actual = frame:preprocess(text1)
	local expected = frame:preprocess(text2)
	self:calculate_output(text1, expected, actual, options)
end

function UnitTester:preprocess_equals_compare(live, sandbox, expected, options)
	options = options or {}
	local live_text = frame:preprocess(live)
	local sandbox_text = frame:preprocess(sandbox)
	local highlight_live = false
	local highlight_sandbox = false
	num_runs = num_runs + 1
	local compared_live = live_text
	local compared_sandbox = sandbox_text
	local compared_expected = expected
	if options.templatestyles then
		local pattern = '(\127[^\127]*UNIQ%-%-templatestyles%-)(%x+)(%-QINU[^\127]*\127)'
		local _, expected_stripmarker_id = compared_expected:match(pattern)				-- when module rendering has templatestyles strip markers, use ID from expected to prevent false test fail
		if expected_stripmarker_id then
			compared_live = compared_live:gsub(pattern, '%1' .. expected_stripmarker_id .. '%3')	-- replace actual id with expected id; ignore second capture in pattern
			compared_sandbox = compared_sandbox:gsub(pattern, '%1' .. expected_stripmarker_id .. '%3')	-- replace actual id with expected id; ignore second capture in pattern
			compared_expected = compared_expected:gsub(pattern, '%1' .. expected_stripmarker_id .. '%3')		-- account for other strip markers
		end
	end
	if options.stripmarker then
		local pattern = '(\127[^\127]*UNIQ%-%-%l+%-)(%x+)(%-%-?QINU[^\127]*\127)'
		local _, expected_stripmarker_id = compared_expected:match(pattern)
		if expected_stripmarker_id then
			compared_live = compared_live:gsub(pattern, '%1' .. expected_stripmarker_id .. '%3')
			compared_sandbox = compared_sandbox:gsub(pattern, '%1' .. expected_stripmarker_id .. '%3')
			compared_expected = compared_expected:gsub(pattern, '%1' .. expected_stripmarker_id .. '%3')
		end
	end
	local success = compared_live == compared_expected and compared_sandbox == compared_expected
	if not success then
		if compared_live ~= compared_expected then
			num_failures = num_failures + 1
			highlight_live = true
		end

		if compared_sandbox ~= compared_expected then
			num_failures_sandbox = num_failures_sandbox + 1
			highlight_sandbox = true
		end
	end

	-- Sort the wikitext for displaying the results
	if options.combined then
		-- We need 2 rows available for the expected, live, and sandbox columns
		-- Top one is parsed, bottom is unparsed
		local differs_at = ''
		local highlight_diff_live, highlight_diff_sandbox = return_varargs, return_varargs
		local diff_live, diff_sandbox = 0,0
		if self.differs_at then
			diff_live = first_difference(compared_expected, compared_live)
			diff_sandbox = first_difference(compared_expected, compared_sandbox)
			differs_at = ' \n| rowspan=2|' .. (diff_live or diff_sandbox)
			if type(diff_live) == "number" then
				highlight_diff_live = highlight_difference
			end
			if type(diff_sandbox) == "number" then
				highlight_diff_sandbox = highlight_difference
			end
		end
		
		result_table:insert(
			'| ', 'rowspan=2|', not highlight_live and tick or cross, not highlight_sandbox and tick or cross,
			' \n| rowspan=2|', mw.text.nowiki(live),
			should_highlight and highlight_live and ' \n| style="background: #fc0;" | ' or ' \n| ',
			highlight_diff_live(live_text, expected, diff_live),
			should_highlight and highlight_sandbox and ' \n| style="background: #fc0;" | ' or ' \n| ',
			highlight_diff_sandbox(sandbox_text, expected, diff_sandbox),
			' \n| ',
			expected,
			differs_at,
			should_highlight and highlight_sandbox and ' \n|-\n| style="background: #fc0;" | ' or ' \n|-\n| ',
			highlight_diff_live(mw.text.nowiki(live_text), mw.text.nowiki(expected), first_difference(mw.text.nowiki(expected), mw.text.nowiki(live_text))),
			should_highlight and highlight_sandbox and ' \n| style="background: #fc0;" | ' or ' \n| ',
			highlight_diff_sandbox(mw.text.nowiki(sandbox_text), mw.text.nowiki(expected), first_difference(mw.text.nowiki(expected), mw.text.nowiki(sandbox_text))),
			' \n| ',
			mw.text.nowiki(expected),
			'\n|-\n'
		)
	else
		-- Display normally with whichever option was preferred (nowiki/parsed)
		local differs_at = ''
		local formatting = options.nowiki and mw.text.nowiki or return_varargs
		local formated_expected, formated_live, formated_sandbox = formatting(expected), formatting(live_text), formatting(sandbox_text)
		if self.differs_at then
			local diff = first_difference(compared_expected, live_text)
			local diff2 = first_difference(compared_expected, sandbox_text)
			differs_at = ' \n| ' .. (diff or diff2)
			if type(diff) == "number" then
				formated_live = highlight_difference(formated_live, formated_expected, first_difference(formated_live, formated_expected))
			end
			if type(diff2) == "number" then
				formated_sandbox = highlight_difference(formated_sandbox, formated_expected, first_difference(formated_sandbox, formated_expected))
			end
		end
		result_table:insert(
			'| ', not highlight_live and tick or cross, not highlight_sandbox and tick or cross,
			' \n| ',
			mw.text.nowiki(live),
			should_highlight and highlight_live and ' \n| style="background: #fc0;" | ' or ' \n| ',
			formated_live,
			should_highlight and highlight_sandbox and ' \n| style="background: #fc0;" | ' or ' \n| ',
			formated_sandbox,
			' \n| ',
			formated_expected,
			differs_at,
			'\n|-\n'
		)
	end
end

function UnitTester:preprocess_equals_preprocess_many(prefix1, suffix1, prefix2, suffix2, cases, options)
	for _, case in ipairs(cases) do
		self:preprocess_equals_preprocess(prefix1 .. case[1] .. suffix1, prefix2 .. (case[2] and case[2] or case[1]) .. suffix2, options)
	end
end

function UnitTester:preprocess_equals_sandbox_many(module, function_name, cases, options)
	for _, case in ipairs(cases) do
		local live = module .. '|' .. function_name .. '|' .. case[1] .. '}}'
		local sandbox = module .. '/sandbox|' .. function_name .. '|' .. case[1] .. '}}'
		self:preprocess_equals_compare(live, sandbox, case[2], options)
	end
end

function UnitTester:equals(name, actual, expected, options)
	num_runs = num_runs + 1
	if actual == expected then
		result_table:insert('| ', tick)
	else
		result_table:insert('| ', cross)
		num_failures = num_failures + 1
	end
	local formatting = (options and options.nowiki and mw.text.nowiki) or return_varargs
	local differs_at = self.differs_at and (' \n| ' .. first_difference(expected, actual)) or ''
	local display = options and options.display or return_varargs
	result_table:insert(' \n| ', name, ' \n| ',
		formatting(tostring(display(expected))), ' \n| ',
		formatting(tostring(display(actual))), differs_at, '\n|-\n')
end

local deep_compare; do
	--//pulled from [[wikt:Module:table/deepEquals]]
	local function is_eq(a, b, seen, include_mt)
		-- If `a` and `b` have been compared before, return the memoized result. This will usually be true, since failures normally fail the whole check outright, but match failures are tolerated during the laborious check without this happening, since it compares key/value pairs until it finds a match, so it could be false.
		local memo_a = seen[a]
		if memo_a then
			local result = memo_a[b]
			if result ~= nil then
				return result
			end
			-- To avoid recursive references causing infinite loops, assume the tables currently being compared are equivalent by memoizing the comparison as true; this will be corrected to false if there's a match failure.
			memo_a[b] = true
		else
			memo_a = {[b] = true}
			seen[a] = memo_a
		end
		-- Don't bother checking `memo_b` for `a`, since if `a` and `b` had been compared before then `b` would be in `memo_a`, but it isn't.
		local memo_b = seen[b]
		if memo_b then
			memo_b[a] = true
		else
			memo_b = {[a] = true}
			seen[b] = memo_b
		end
		-- If `include_mt` is set, check the metatables are equivalent.
		if include_mt then
			local mt_a, mt_b = getmetatable(a), getmetatable(b)
			if not (mt_a == mt_b or type(mt_a) == "table" and type(mt_b) == "table" and is_eq(mt_a, mt_b, seen, true)) then
				memo_a[b], memo_b[a] = false, false
				return false
			end
		end
		-- Copy all key/values pairs in `b` to `remaining_b`, and count the size: this uses `pairs`, which will also be used to iterate over `a`, ensuring that `a` and `b` are iterated over using the same iterator. This is necessary to ensure that `deepEquals(a, b)` and `deepEquals(b, a)` always give the same result. Simply iterating over `a` while accessing keys in `b` for comparison would ignore any `__pairs` metamethod that `b` has, which could cause asymmetrical outputs if `__pairs` returns more or less than the complete set of key/value pairs accessible via `__index`, so using `pairs` for both `a` and `b` prevents this.
		-- TODO: handle exotic `__pairs` methods which return the same key multiple times with different values.
		local remaining_b, size_b = {}, 0
		for k_b, v_b in pairs(b) do
			remaining_b[k_b], size_b = v_b, size_b + 1
		end
		-- Fast check: iterate over the keys in `a`, checking if an equivalent value exists at the same key in `remaining_b`. As matches are found, key/value pairs are removed from `remaining_b`. If any keys in `a` or `remaining_b` are tables, the fast check will only work if the exact same object exists as a key in the other table. Any others from `a` that don't match anything in `remaining_b` are added to `remaining_a`, while those in `remaining_b` that weren't found will still remain once the loop ends. `remaining_a` and `remaining_b` are then compared at the end with the laborious check.
		local size_a, remaining_a = 0
		for k, v_a in pairs(a) do
			local v_b = remaining_b[k]
			-- If `k` isn't in `remaining_b`, `a` and `b` can't be equivalent unless it's a table.
			if v_b == nil then
				if type(k) ~= "table" then
					memo_a[b], memo_b[a] = false, false
					return false
				-- Otherwise, add the `k`/`v_a` pair to `remaining_a` for the laborious check.
				elseif not remaining_a then
					remaining_a = {}
				end
				remaining_a[k], size_a = v_a, size_a + 1
			-- Otherwise, if `k` exists in `a` and `remaining_b`, `v_a` and `v_b` must be equivalent for there to be a match.
			elseif v_a == v_b or type(v_a) == "table" and type(v_b) == "table" and is_eq(v_a, v_b, seen, include_mt) then
				remaining_b[k], size_b = nil, size_b - 1
			else
				memo_a[b], memo_b[a] = false, false
				return false
			end
		end
		-- Must be the same number of remaining keys in each table.
		if size_a ~= size_b then
			memo_a[b], memo_b[a] = false, false
			return false
		-- If the size is 0, there's nothing left to check.
		elseif size_a == 0 then
			return true
		end
		-- Laborious check: since it's not possible to use table lookups to check if two keys are equivalent when they're tables, check each key/value pair in `remaining_a` against every key/value pair in `remaining_b` until a match is found, removing the matching key/value pair from `remaining_b` each time, to ensure one-to-one equivalence.
		for k_a, v_a in next, remaining_a do
			local success
			for k_b, v_b in next, remaining_b do
				-- Keys/value pairs must be equivalent in order to match.
				if ( -- More efficient to compare the values first, as they might not be tables.
					(v_a == v_b or type(v_a) == "table" and type(v_b) == "table" and is_eq(v_a, v_b, seen, include_mt)) and
					(k_a == k_b or type(k_a) == "table" and type(k_b) == "table" and is_eq(k_a, k_b, seen, include_mt))
				) then
					-- Remove matched key from `remaining_b`, and break the inner loop.
					success, remaining_b[k_b] = true, nil
					break
				end
			end
			-- Fail if `remaining_b` runs out of keys, as the `k_a`/`v_a` pair still hasn't matched.
			if not success then
				memo_a[b], memo_b[a] = false, false
				return false
			end
		end
		-- If every key/value pair in `remaining_a` matched with one in `remaining_b`, `a` and `b` must be equivalent. Note that `remaining_b` will now be empty, since the laborious check only starts if `remaining_a` and `remaining_b` are the same size.
		return true
	end
	deep_compare = function(a, b, ignore_mt)
		-- Do simple checks before calling is_eq to avoid generating an unnecessary memo.
		-- Simple equality check and type check; if not a ~= b, a and b can only be equivalent if they're both tables.
		return a == b or type(a) == "table" and type(b) == "table" and is_eq(a, b, {}, not ignore_mt)
	end
end

local function val_to_str(obj)
	local function table_key_to_str(k)
		if type(k) == 'string' and mw.ustring.match(k, '^[_%a][_%a%d]*$') then
			return k
		else
			return '[' .. val_to_str(k) .. ']'
		end
	end

	if type(obj) == 'string' then
		obj = mw.ustring.gsub(obj, '\n', '\\n')
		if mw.ustring.match(mw.ustring.gsub(obj, '[^\'"]', ''), '^"+$') then
			return "'" .. obj .. "'"
		end
		return '"' .. mw.ustring.gsub(obj, '"', '\\"' ) .. '"'
	elseif type(obj) == 'table' then
		local result, checked = {}, {}
		for k, v in ipairs(obj) do
			table.insert(result, val_to_str(v))
			checked[k] = true
		end
		for k, v in pairs(obj) do
			if not checked[k] then
				table.insert(result, table_key_to_str(k) .. '=' .. val_to_str(v))
			end
		end
		return '{' .. table.concat(result, ',') .. '}'
	else
		return tostring(obj)
	end
end
local function insert_differences(keys, t1, t2)
	for k, v1 in pairs(t1) do
		local v2 = t2[k]
		if v2 == nil or not deep_compare(v1, v2, true) then
			table.insert(keys, k)
		end
	end
end

local function get_differing_keys(t1, t2)
	local ty1 = type(t1)
	if not (ty1 == type(t2) and ty1 == "table") then
		return nil
	end
	
	local keys = {}
	insert_differences(keys, t1, t2)
	insert_differences(keys, t2, t1)

	return keys
end

local function extract_keys(t, keys)
	if not keys then
		return t
	end
	local new_t = {}
	for _, key in ipairs(keys) do
		new_t[key] = t[key]
	end
	return new_t
end

function UnitTester:equals_deep(name, actual, expected, options)
	num_runs = num_runs + 1
	local actual_str, expected_str
	local success = deep_compare(actual, expected, true)
	if success then
		result_table:insert('| ', tick)
		if options and options.show_table_difference then
			actual_str = ''
			expected_str = ''
		end
	else
		if options and options.show_table_difference then
			local keys = get_differing_keys(actual, expected)
			actual_str = val_to_str(extract_keys(actual, keys))
			expected_str = val_to_str(extract_keys(expected, keys))
		end
	end
	if (not options) or not options.show_table_difference then
		actual_str = val_to_str(actual)
		expected_str = val_to_str(expected)
	end
	local formatting = (options and options.nowiki and mw.text.nowiki) or return_varargs
	local differs_at = self.differs_at and (' \n| ' .. first_difference(expected_str, actual_str)) or ''
	result_table:insert(' \n| ', name, ' \n| ', formatting(expected_str),
		' \n| ', formatting(actual_str), differs_at, '\n|-\n')
end

function UnitTester:iterate(examples, func)
	require 'libraryUtil'.checkType('iterate', 1, examples, 'table')
	if type(func) == 'string' then
		func = self[func]
	elseif type(func) ~= 'function' then
		error(("bad argument #2 to 'iterate' (expected function or string, got %s)")
			:format(type(func)), 2)
	end

	for i, example in ipairs(examples) do
		if type(example) == 'table' then
			func(self, unpack(example))
		elseif type(example) == 'string' then
			self:heading(example)
		else
			error(('bad example #%d (expected table, got %s)')
				:format(i, type(example)), 2)
		end
	end
end

function UnitTester:heading(text)
	result_table:insert_format(' ! colspan="%u" style="text-align: left;" | %s \n |- \n ',
		self.columns, text)
end

function UnitTester:runTest(name, test)
	local success, details = xpcall(function() test(self) end, function(err) return {error = err, trace = debug.traceback()} end)
	if not success then
		num_failures = num_failures + 1
		num_runs = num_runs + 1
		result_table:insert('| ', 'rowspan=2|', cross, ' \n| ', name, ' \n| ')
		result_table:insert_format(' colspan="%u"| <strong class="error">Lua error during testing -- %s;traceback:<br>%s</strong>\n',
			self.columns, details.error, frame:extensionTag("pre", details.trace or "(no traceback)"))
		result_table:insert('\n|-\n')
	end
end

function UnitTester:run(frame_arg)
	frame = frame_arg or mw.getCurrentFrame()
	self.frame = frame
	self.differs_at = frame.args['differs_at']
	self.live_sandbox = frame.args['live_sandbox']
	tick = frame:preprocess(cfg.successIndicator)
	cross = frame:preprocess(cfg.failureIndicator)

	local table_header = '{| class="wikitable unit-tests-result"\n|+ %s\n! !! '
	if self.live_sandbox then
		table_header = table_header .. cfg.testString .. ' !! ' .. cfg.liveString
			.. ' !! ' .. cfg.sandboxString .. ' !! ' .. cfg.expectedString
	else
		table_header = table_header .. cfg.testString .. ' !! ' .. cfg.expectedString .. ' !! ' .. cfg.actualString
	end
	if frame.args.highlight then
		should_highlight = true
	end

	self.columns = 4
	if self.differs_at then
		table_header = table_header .. ' !! ' .. cfg.differsString
		self.columns = self.columns + 1
	end
	if self._tests._last then
		table.insert(self._tests, self._tests._last)
		self._tests._last = nil
	end
	-- Add results to the results table.
	for _, testDetails in ipairs(self._tests) do
		result_table:insert_format('<h2>%s</h2>\n', testDetails.name)
		result_table:insert_format(table_header .. '\n|-\n', testDetails.name)
		self:runTest(testDetails.name, testDetails.test)
		result_table:insert('|}\n')
	end
	local refresh_link = tostring(mw.uri.fullUrl(mw.title.getCurrentTitle().fullText, 'action=purge&forcelinkupdate=1'))
	if self.live_sandbox then
		local live, sandbox
		if num_runs == 0 then
			live = cfg.noTestsRunSummary
		elseif num_failures ~= 0 then
			live = mw.message.newRawMessage(cfg.liveFailureSummary, num_runs, num_failures):plain()
			live = frame:preprocess(live)
		else
			live = mw.message.newRawMessage(cfg.liveSuccessSummary, num_runs):plain()
			live = frame:preprocess(live)
		end
		if num_runs == 0 then
			sandbox = ''
		elseif num_failures_sandbox ~= 0 then
			sandbox = mw.message.newRawMessage(cfg.sandboxFailureSummary, num_runs, num_failures_sandbox):plain()
			sandbox = frame:preprocess(sandbox)
		else
			sandbox = mw.message.newRawMessage(cfg.sandboxSuccessSummary, num_runs):plain()
			sandbox = frame:preprocess(sandbox)
		end
		local cat = (num_failures ~= 0 or num_failures_sandbox ~= 0) and 
			(cfg.failureCategory .. " <span class='plainlinks unit-tests-refresh'>[" .. refresh_link .. " (refresh)]</span>") or ''
		return live .. ' ' .. sandbox .. cat .. '\n\n' .. frame:preprocess(result_table:concat())
	else
		local msg;
		if num_runs == 0 then
			msg = cfg.noTestsRunSummary
		elseif num_failures ~= 0 then
			msg = mw.message.newRawMessage(cfg.failureSummary, num_runs, num_failures):plain()
			msg = frame:preprocess(msg)
			msg = msg .. cfg.failureCategory
			msg = msg .. " <span class='plainlinks unit-tests-refresh'>[" .. refresh_link .. " (refresh)]</span>"
		else
			msg = mw.message.newRawMessage(cfg.successSummary, num_runs):plain()
			msg = frame:preprocess(msg)
		end
		return msg .. '\n\n' .. frame:preprocess(result_table:concat())
	end
end

-- Set up metatable
UnitTester.__meta = {}
UnitTester.__meta.__index = UnitTester
function UnitTester.__meta:__newindex(key, value)
	if type(key) == 'string' and key:find('^test') and type(value) == 'function' then
		-- Store test functions in the order they were defined
		if key == self.runLast or key == rawget(_G, "runLast") then
			self._tests._last = {name = key, test = value}
		else
			table.insert(self._tests, {name = key, test = value})
		end
	else
		rawset(self, key, value)
	end
end

function UnitTester.new()
	local o = {}
	o.runLast = '' -- puts a test at the end of the page
	o._tests = {}
	setmetatable(o, UnitTester.__meta)
	function o.run_tests(frame_arg) return o:run(frame_arg) end
	return o
end

local p = UnitTester.new()

return p
Module:UnitTests

Methods

run_tests

preprocess_equals

preprocess_equals_many

preprocess_equals_preprocess

preprocess_equals_preprocess_many

preprocess_equals_sandbox_many

equals

equals_deep

Test options

nowiki

combined

noexpectation

templatestyles

stripmarker

display

See also
