Module:UnitTests/sandbox2

UnitTests provides a unit test facility that can be used by other scripts using require. See Wikipedia:Lua for details. The following is a sample from Module:Example/testcases:

-- Unit tests for [[Module:Example]]. Click talk page to run tests.
local p = require('Module:UnitTests')

function p:test_hello()
    self:preprocess_equals('{{#invoke:Example | hello}}', 'Hello World!')
end

return p

The talk page Module talk:Example/testcases executes it with {{#invoke: Example/testcases | run_tests}}. Test methods like test_hello above must begin with "test".

Methods

run_tests

run_tests: Runs all tests. Normally used on talk page of unit tests.
```
{{#invoke:Example/testcases|run_tests}}
```
If differs_at is specified, a column will be added showing the first character position where the expected and actual results differ.
```
{{#invoke:Example/testcases|run_tests|differs_at=1}}
```
If highlight is specified, failed tests will be highlighted to make them easier to spot. A user script that moves failed tests to the top is also available.
```
{{#invoke:Example/testcases|run_tests|highlight=1}}
```
If live_sandbox is specified, the header will show the columns "Test", "Live", "Sandbox", "Expected". This is required when using the preprocess_equals_sandbox_many method.

preprocess_equals

preprocess_equals(text, expected, options): Gives a piece of wikitext to preprocess and an expected resulting value. Scripts and templates can be invoked in the same manner they would be in a page.
```
self:preprocess_equals('{{#invoke:Example | hello}}', 'Hello, world!', {nowiki=1})
```

preprocess_equals_many

preprocess_equals_many(prefix, suffix, cases, options): Performs a series of preprocess_equals() calls on a set of given pairs. Automatically adds the given prefix and suffix to each text.
```
self:preprocess_equals_many('{{#invoke:Example | hello_to |', '}}', {
    {'John', 'Hello, John!'},
    {'Jane', 'Hello, Jane!'},
}, {nowiki=1})
```

preprocess_equals_preprocess

preprocess_equals_preprocess(text, expected, options): Gives two pieces of wikitext to preprocess and determines if they produce the same value. Useful for comparing scripts to existing templates.
```
self:preprocess_equals_preprocess('{{#invoke:Example | hello}}', '{{Hello}}', {nowiki=1})
```

preprocess_equals_preprocess_many

preprocess_equals_preprocess_many(prefix1, suffix1, prefix2, suffix2, cases, options): Performs a series of preprocess_equals_preprocess() calls on a set of given pairs. The prefix/suffix supplied for both arguments is added automatically. If in any case the second part is not specified, the first part will be used.
```
self:preprocess_equals_preprocess_many('{{#invoke:ConvertNumeric | numeral_to_english|', '}}', '{{spellnum', '}}', {
    {'2'}, -- equivalent to {'2','2'},
    {'-2', '-2.0'},
}, {nowiki=1})
```

preprocess_equals_sandbox_many

preprocess_equals_sandbox_many(module, function, cases, options): Performs a series of preprocess_equals_compare() calls on a set of given pairs. The test compares the live version of the module vs the /sandbox version and vs an expected result. Ensure live_sandbox is specified or there may be some errors in the output.
```
self:preprocess_equals_sandbox_many('{{#invoke:Example', 'hello_to', {
    {'John', 'Hello, John!'},
    {'Jane', 'Hello, Jane!'},
}, {nowiki=1})
```

equals

equals(name, actual, expected, options): Gives a computed value and the expected value, and checks if they are equal according to the == operator. Useful for testing modules that are designed to be used by other modules rather than using #invoke.
```
self:equals('Simple addition', 2 + 2, 4, {nowiki=1})
```

equals_deep

equals_deep(name, actual, expected, options): Like equals, but handles tables by doing a deep comparison. Neither value should contain circular references, as they are not handled by the current implementation and may result in an infinite loop.
```
self:equals_deep('Table comparison', createRange(1,3), {1,2,3}, {nowiki=1})
```

Test options

These are the valid options that can be passed into the options parameters of the test functions listed above.

nowiki

Enabling this wraps the output text in <nowiki>...</nowiki> tags to avoid the text being rendered (E.g. <span>[[Example|Page]]</span> instead of Page)

combined

Enabling this will display the output text in both the rendered mode and the nowiki mode to allow for both a raw text and visual comparison.

templatestyles

Enabling this fixes the IDs in the strip markers <templatestyles>...</templatestyles> produces when processed to avoid incorrectly failing the tests.

stripmarker

Enabling this fixes the IDs in all strip markers produces when processed to avoid incorrectly failing the tests.

display

An optional function that changes how the output from the tests are displayed. This doesn't effect the comparison process.

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

local frame, tick, cross
local result_table_header = "{|class=\"wikitable\"\n! !! Text !! Expected !! Actual"
local result_table = ''
local num_failures = 0

function first_difference(s1, 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

function UnitTester:preprocess_equals(text, expected, options)
    local actual = frame:preprocess(text)
    if actual == expected then
        result_table = result_table .. '| ' .. tick
    else
        result_table = result_table .. '| ' .. cross
        num_failures = num_failures + 1
    end
    local nowiki_open = (options and options.nowiki) and '<nowiki>' or ''
    local nowiki_close = (options and options.nowiki) and '</nowiki>' or ''
    local differs_at = self.differs_at and (' \n| ' .. first_difference(expected, actual)) or ''
    result_table = result_table .. ' \n| <nowiki>' .. text:gsub('%|', '&#124;') .. '</nowiki> \n| ' .. nowiki_open .. expected .. nowiki_close .. ' \n| ' .. nowiki_open .. actual .. nowiki_close .. differs_at .. "\n|-\n"
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)
    if actual == expected then
        result_table = result_table .. '| ' .. tick
    else
        result_table = result_table .. '| ' .. cross
        num_failures = num_failures + 1
    end
    local nowiki_open = (options and options.nowiki) and '<nowiki>' or ''
    local nowiki_close = (options and options.nowiki) and '</nowiki>' or ''
    local differs_at = self.differs_at and (' \n| ' .. first_difference(expected, actual)) or ''
    result_table = result_table .. ' \n| <nowiki>' .. text1:gsub('%|', '&#124;') .. '</nowiki> \n| ' .. nowiki_open .. expected .. nowiki_close .. ' \n| ' .. nowiki_open .. actual .. nowiki_close .. differs_at .. "\n|-\n"
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:equals(name, actual, expected, options)
    if actual == expected then
        result_table = result_table .. '| ' .. tick
    else
        result_table = result_table .. '| ' .. cross
        num_failures = num_failures + 1
    end
    local nowiki_open = (options and options.nowiki) and '<nowiki>' or ''
    local nowiki_close = (options and options.nowiki) and '</nowiki>' or ''
    local differs_at = self.differs_at and (' \n| ' .. first_difference(expected, actual)) or ''
    result_table = result_table .. ' \n| ' .. name .. ' \n| ' .. nowiki_open .. tostring(expected) .. nowiki_close .. ' \n| ' .. nowiki_open .. tostring(actual) .. nowiki_close .. differs_at .. "\n|-\n"
end

local function deep_compare(t1, t2, ignore_mt)
    local ty1 = type(t1)
    local ty2 = type(t2)
    if ty1 ~= ty2 then return false end
    if ty1 ~= 'table' and ty2 ~= 'table' then return t1 == t2 end
    
    local mt = getmetatable(t1)
    if not ignore_mt and mt and mt.__eq then return t1 == t2 end
    
    for k1, v1 in pairs(t1) do
        local v2 = t2[k1]
        if v2 == nil or not deep_compare(v1, v2) then return false end
    end
    for k2, v2 in pairs(t2) do
        local v1 = t1[k2]
        if v1 == nil or not deep_compare(v1, v2) then return false end
    end

    return true
end

function val_to_str(v)
    if type(v) == 'string' then
        v = mw.ustring.gsub(v, '\n', '\\n')
        if mw.ustring.match(mw.ustring.gsub(v, '[^\'"]', ''), '^"+$') then
            return "'" .. v .. "'"
        end
        return '"' .. mw.ustring.gsub(v, '"', '\\"' ) .. '"'
    else
        return type(v) == 'table' and table_to_str(v) or tostring(v)
    end
end

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

function table_to_str(tbl)
    local result, done = {}, {}
    for k, v in ipairs(tbl) do
        table.insert(result, val_to_str(v))
        done[k] = true
    end
    for k, v in pairs(tbl) do
        if not done[k] then
            table.insert(result, table_key_to_str(k) .. '=' .. val_to_str(v))
        end
    end
    return '{' .. table.concat(result, ',') .. '}'
end

function UnitTester:equals_deep(name, actual, expected, options)
    if deep_compare(actual, expected) then
        result_table = result_table .. '| ' .. tick
    else
        result_table = result_table .. '| ' .. cross
        num_failures = num_failures + 1
    end
    local nowiki_open = (options and options.nowiki) and '<nowiki>' or ''
    local nowiki_close = (options and options.nowiki) and '</nowiki>' or ''
    local actual_str = val_to_str(actual)
    local expected_str = val_to_str(expected)
    local differs_at = self.differs_at and (' \n| ' .. first_difference(expected_str, actual_str)) or ''
    result_table = result_table .. ' \n| ' .. name .. ' \n| ' .. nowiki_open .. expected_str .. nowiki_close .. ' \n| ' .. nowiki_open .. actual_str .. nowiki_close .. differs_at .. "\n|-\n"
end

function UnitTester:run(frame_arg)
    frame = frame_arg
    self.frame = frame
    self.differs_at = frame.args['differs_at']
    tick = frame:preprocess('{{Tick}}')
    cross = frame:preprocess('{{Cross}}')

    local table_header = result_table_header
    if self.differs_at then
        table_header = table_header .. ' !! Differs at'
    end

    -- Sort results into alphabetical order.
    local self_sorted = {}
    for key,value in pairs(self) do
        if key:find('^test') then
            table.insert(self_sorted, key)
        end
    end
    table.sort(self_sorted)
    -- Add results to the results table.
    for i,value in ipairs(self_sorted) do
        result_table = result_table .. "'''" .. value .. "''':\n" .. table_header .. "\n|-\n"
        self[value](self)
        result_table = result_table .. "|}\n\n"    
    end

    return (num_failures == 0 and "<font color=\"#008000\">'''All tests passed.'''</font>" or "<font color=\"#800000\">'''" .. num_failures .. " tests failed.'''</font>") .. "\n\n" .. frame:preprocess(result_table)
end

function UnitTester:new()
    local o = {}
    setmetatable(o, self)
    self.__index = self
    return o
end

local p = UnitTester:new()
function p.run_tests(frame) return p:run(frame) end
return p