Module:Util/testcases

This module implements the test cases for Module:Util.

N3 tests failed.

	Name	Expected	Actual
Y	test_args_stats__errors
Y	test_args_stats__min_max
Y	test_args_stats__value
Y	test_cast_boolean
Y	test_cast_number
Y	test_cast_number__error_invalid_number
Y	test_cast_number__error_max
Y	test_cast_number__error_min
Y	test_cast_number__invalid_with_default
Y	test_html_abbr
N	test_html_error	<span class="module-error">Module Error: Test</span>	<strong class="error"><span class="module-error">Module Error: Test</span></strong>
N	test_misc_add_category	[[Category:test]]
Y	test_misc_get_frame
Y	test_misc_is_frame
N	test_smw_safeguard	Lua error -- Module:Util/testcases:112: attempt to index field 'smw' (a nil value)
Y	test_string_split_args
Y	test_table_find_in_nested_array__assoc

local util = require('Module:Util') -- the module to be tested
local ScribuntoUnit = require('Module:ScribuntoUnit')
local suite = ScribuntoUnit:new()

-- ----------------------------------------------------------------------------
-- Tests: util.cast 
-- ----------------------------------------------------------------------------

function suite:test_cast_boolean()
    self:assertEquals(true, util.cast.boolean('true'))
    self:assertEquals(true, util.cast.boolean(5))
    self:assertEquals(true, util.cast.boolean(true))
    self:assertEquals(false, util.cast.boolean('false'))
    self:assertEquals(false, util.cast.boolean(0))
    self:assertEquals(false, util.cast.boolean(false))
    self:assertEquals(false, util.cast.boolean(nil))
end

function suite:test_cast_number()
    -- boolean
    self:assertEquals(1, util.cast.number(true))
    self:assertEquals(0, util.cast.number(false))
    -- number
    self:assertEquals(5, 5)
    self:assertEquals(5, 5.0)
    -- string
    self:assertEquals(5, util.cast.number('5'))
    self:assertEquals(5, util.cast.number('5.0'))
    self:assertEquals(5, util.cast.number('5e0'))
end

function suite:test_cast_number__error_invalid_number()
    self:assertFalse(pcall(util.cast.number, 'wrong'))
end

function suite:test_cast_number__error_min()
    self:assertFalse(pcall(util.cast.number, 5, {min=6}))
end

function suite:test_cast_number__error_max()
    self:assertFalse(pcall(util.cast.number, 5, {max=4}))
end

function suite:test_cast_number__invalid_with_default()
    self:assertEquals(5, util.cast.number('wrong', {default=5}))
end

-- ----------------------------------------------------------------------------
-- Tests: util.args
-- ----------------------------------------------------------------------------

function suite:test_args_stats__value()
    local args = {stat1_id='stat1', stat1_value='1'}
    util.args.stats(args, {})
    self:assertEquals(args.stat1_value, 1)
end

function suite:test_args_stats__min_max()
    local args = {stat1_id='stat1', stat1_min='1', stat1_max='2'}
    util.args.stats(args, {})
    self:assertEquals(args.stat1_min, 1)
    self:assertEquals(args.stat1_max, 2)
    self:assertEquals(args.stat1_avg, 1.5)
end

function suite:test_args_stats__errors()
    local args = {stat1_id='stat1', stat1_value='1', stat1_min='1'}
    self:assertFalse(pcall(util.args.stats, args, {}))
    
    args = {stat1_id='stat1', stat1_min='1'}
    self:assertFalse(pcall(util.args.stats, args, {}))
end


-- ----------------------------------------------------------------------------
-- Tests: util.html
-- ----------------------------------------------------------------------------

function suite:test_html_abbr()
    self:assertEquals('<abbr title="content" class="cls">test</abbr>', util.html.abbr('test', 'content', 'cls'))
end

function suite:test_html_error()
    self:assertEquals('<span class="module-error">Module Error: Test</span>', util.html.error{msg='Test'})
    self:assertEquals('<span class="module-error">Module Error: </span>', util.html.error())
end

-- ----------------------------------------------------------------------------
-- Tests: util.misc
-- ----------------------------------------------------------------------------

function suite:test_misc_is_frame()
    self:assertFalse(util.misc.is_frame(), 'Test failed for nil')
    self:assertFalse(util.misc.is_frame(0), 'Test failed for number')
    self:assertFalse(util.misc.is_frame({}), 'Test failed for unrelated table')
    self:assertTrue(util.misc.is_frame(mw.getCurrentFrame()), 'Test failed for correct frame object')
end

function suite:test_misc_get_frame()
    util.misc.get_frame()
end

function suite:test_misc_add_category()
    self:assertEquals('[[Category:test]]', util.misc.add_category({'test'}, {ingore_blacklist=true}))
end

-- ----------------------------------------------------------------------------
-- Tests: util.smw
-- ----------------------------------------------------------------------------

function suite:test_smw_safeguard()
    self:assertTrue(util.smw.safeguard(), 'Should return true for module namespace')
end

-- ----------------------------------------------------------------------------
-- Tests: util.string
-- ----------------------------------------------------------------------------

function suite:test_string_split_args()
    self:assertDeepEquals({'a','b',x='c','d', y='e'}, util.string.split_args('a,b,x=c,d,y=e'), 'Basic functionality test failed.')
    self:assertDeepEquals({'a','b',x='c','d', y='e'}, util.string.split_args('a;b;x=c;d;y=e', {sep=';'}), 'Separator failed.')
    self:assertFalse(pcall(util.string.split_args, 'a,b=1=1'), 'Testing errornous string failed (duplicate =).')
end

-- ----------------------------------------------------------------------------
-- Tests: util.table
-- ----------------------------------------------------------------------------

local data_array = {
    { 5, 10 },
    { 6, 12 },
}

local data_assoc = {
    {
        a = 5,
        b = 10,
    },
    {
        a = 6,
        b = 12,
    },
}

function suite:test_table_find_in_nested_array__assoc()
    self:assertEquals(6, util.table.find_in_nested_array{tbl=data_assoc, key='a', value=6})
    self:assertEquals(nil, util.table.find_in_nested_array{tbl=data_assoc, key='a', value=0})
    self:assertEquals(data_assoc[2], util.table.find_in_nested_array{tbl=data_assoc, key='a', value=6, rtrvalue=false})
    self:assertEquals(12, util.table.find_in_nested_array{tbl=data_assoc, key='a', value=6, rtrkey='b'})
    self:assertEquals(6, util.table.find_in_nested_array{tbl=data_assoc, key={'a', 'b'}, value=12, rtrkey='a'})
end

-- ----------------------------------------------------------------------------

return suite