Maska: naimportována 1 revize

2021-03-23T11:52:13Z

naimportována 1 revize

← Starší verze	Verze z 23. 3. 2021, 13:52
(Žádný rozdíl)

Module>Capankajsmilyo: +

2019-05-22T11:25:27Z

Nová stránka

local getArgs = require('Module:Arguments/sandbox').getArgs
local ScribuntoUnit = require('Module:ScribuntoUnit')
local suite = ScribuntoUnit:new()
local libName = 'Arguments'

--------------------------------------------------------------------------
-- Default values
--------------------------------------------------------------------------

local d = {}
d.frameTitle = 'Frame title'
d.parentTitle = 'Parent title'

-- Precedence-testing values
d.firstFrameArg = 'first frame argument'
d.firstParentArg = 'first parent argument'
d.secondParentArg = 'second parent argument'
d.uniqueFrameArg = 'unique frame argument'
d.uniqueFrameArgKey = 'uniqueFrameArgKey'
d.uniqueParentArg = 'unique parent argument'
d.uniqueParentArgKey = 'uniqueParentArgKey'

-- Trimming and whitespace values.
-- Whitespace gets trimmed from named parameters, so keys for these need
-- to be numbers to make this a proper test.
d.blankArg = ''
d.blankArgKey = 100
d.spacesArg = '\n '
d.spacesArgKey = 101
d.untrimmedArg = '\n foo bar '
d.untrimmedArgKey = 102
d.trimmedArg = 'foo bar'
d.valueFuncValue = 'valueFuncValue'
d.defaultValueFunc = function() return d.valueFuncValue end
d.translate = {
foo = 'F00',
bar = '8@r',
baz = '8@z',
qux = 'qUx'
}

-- Helper to run all tests using sandbox version of the library from the debug console. To run against main lib, use =p.run()
function suite.runSandbox()
local frame = mw.getCurrentFrame():newChild{title='testcases', args={module=libName .. '/sandbox', displayMode='log'}}
return suite.run(frame)
end

-- Allow test runner to use the sandbox and the primary versions of the library with the same testcases
function suite:module()
return require('Module:' .. (self.frame and self.frame.args.module or libName))
end

--[[
Library-specific tests
]]

--------------------------------------------------------------------------
-- Helper functions
--------------------------------------------------------------------------

function suite.getFrames(frameTitle, frameArgs, parentTitle, parentArgs)
frameTitle = frameTitle or d.frameTitle
frameArgs = frameArgs or {
d.firstFrameArg,
[d.uniqueFrameArgKey] = d.uniqueFrameArg,
[d.blankArgKey] = d.blankArg,
[d.spacesArgKey] = d.spacesArg,
[d.untrimmedArgKey] = d.untrimmedArg
}
parentTitle = parentTitle or d.parentTitle
parentArgs = parentArgs or {
d.firstParentArg,
d.secondParentArg,
[d.uniqueParentArgKey] = d.uniqueParentArg
}
local currentFrame = mw.getCurrentFrame()
local parent = currentFrame:newChild{title = parentTitle, args = parentArgs}
local frame = parent:newChild{title = frameTitle, args = frameArgs}
return frame, parent
end

function suite.getDefaultArgs(options, frameTitle, frameArgs, parentTitle, parentArgs)
local frame, parent = suite.getFrames(frameTitle, frameArgs, parentTitle, parentArgs)
local args = getArgs(frame, options)
return args
end

function suite:assertError(func, ...)
-- Asserts that executing the function func results in an error.
-- Parameters after func are func's arguments.
local success, msg = pcall(func, ...)
self:assertFalse(success)
end

function suite:assertNumberOfIterations(expected, iterator, t)
local noIterations = 0
for k, v in iterator(t) do
noIterations = noIterations + 1
end
self:assertEquals(expected, noIterations)
end

--------------------------------------------------------------------------
-- Test precedence
--------------------------------------------------------------------------

function suite:assertDefaultPrecedence(args)
self:assertEquals(d.firstFrameArg, args[1])
self:assertEquals(d.secondParentArg, args[2])
self:assertEquals(d.uniqueFrameArg, args[d.uniqueFrameArgKey])
self:assertEquals(d.uniqueParentArg, args[d.uniqueParentArgKey])
end

function suite:testDefaultPrecedence()
self:assertDefaultPrecedence(suite.getDefaultArgs())
end

function suite:testDefaultPrecedenceThroughWrapper()
self:assertDefaultPrecedence(suite.getDefaultArgs{wrappers = {d.parentTitle}, parentOnly = false})
end

function suite:testDefaultPrecedenceThroughNonWrapper()
self:assertDefaultPrecedence(suite.getDefaultArgs({wrappers = d.parentTitle, frameOnly = false}, nil, nil, 'Not the parent title'))
end

function suite:assertParentFirst(args)
self:assertEquals(d.firstParentArg, args[1])
self:assertEquals(d.secondParentArg, args[2])
self:assertEquals(d.uniqueFrameArg, args[d.uniqueFrameArgKey])
self:assertEquals(d.uniqueParentArg, args[d.uniqueParentArgKey])
end

function suite:testParentFirst()
self:assertParentFirst(suite.getDefaultArgs{parentFirst = true})
end

function suite:testParentFirstThroughWrapper()
self:assertParentFirst(suite.getDefaultArgs{wrappers = {d.parentTitle}, parentOnly = false, parentFirst = true})
end

function suite:testParentFirstThroughNonWrapper()
self:assertParentFirst(suite.getDefaultArgs({wrappers = d.parentTitle, frameOnly = false, parentFirst = true}, nil, nil, 'Not the parent title'))
end

function suite:assertParentOnly(args)
self:assertEquals(d.firstParentArg, args[1])
self:assertEquals(d.secondParentArg, args[2])
self:assertEquals(nil, args[d.uniqueFrameArgKey])
self:assertEquals(d.uniqueParentArg, args[d.uniqueParentArgKey])
end

function suite:testParentOnly()
self:assertParentOnly(suite.getDefaultArgs{parentOnly = true})
end

function suite:testParentOnlyThroughWrapper()
self:assertParentOnly(suite.getDefaultArgs{wrappers = {d.parentTitle}})
end

function suite:testParentOnlyThroughSandboxWrapper()
self:assertParentOnly(suite.getDefaultArgs({wrappers = d.parentTitle}, nil, nil, d.parentTitle .. '/sandbox'))
end

function suite:assertFrameOnly(args)
self:assertEquals(d.firstFrameArg, args[1])
self:assertEquals(nil, args[2])
self:assertEquals(d.uniqueFrameArg, args[d.uniqueFrameArgKey])
self:assertEquals(nil, args[d.uniqueParentArgKey])
end

function suite:testFrameOnly()
self:assertFrameOnly(suite.getDefaultArgs{frameOnly = true})
end

function suite:testFrameOnlyThroughNonWrapper()
self:assertFrameOnly(suite.getDefaultArgs({wrappers = d.parentTitle}, nil, nil, 'Not the parent title'))
end

function suite:testDefaultPrecedenceWithWhitespace()
local frame, parent = suite.getFrames(
d.frameTitle,
{' '},
d.parentTitle,
{d.firstParentArg}
)
local args = getArgs(frame)
self:assertEquals(d.firstParentArg, args[1])
end

--------------------------------------------------------------------------
-- Test trimming and blank removal
--------------------------------------------------------------------------

function suite:testDefaultTrimmingAndBlankRemoval()
local args = suite.getDefaultArgs()
self:assertEquals(nil, args[d.blankArgKey])
self:assertEquals(nil, args[d.spacesArgKey])
self:assertEquals(d.trimmedArg, args[d.untrimmedArgKey])
end

function suite:testRemoveBlanksButNoTrimming()
local args = suite.getDefaultArgs{trim = false}
self:assertEquals(nil, args[d.blankArgKey])
self:assertEquals(nil, args[d.spacesArgKey])
self:assertEquals(d.untrimmedArg, args[d.untrimmedArgKey])
end

function suite:testTrimButNoBlankRemoval()
local args = suite.getDefaultArgs{removeBlanks = false}
self:assertEquals(d.blankArg, args[d.blankArgKey])
self:assertEquals('', args[d.spacesArgKey])
self:assertEquals(d.trimmedArg, args[d.untrimmedArgKey])
end

function suite:testNoTrimOrBlankRemoval()
local args = suite.getDefaultArgs{trim = false, removeBlanks = false}
self:assertEquals(d.blankArg, args[d.blankArgKey])
self:assertEquals(d.spacesArg, args[d.spacesArgKey])
self:assertEquals(d.untrimmedArg, args[d.untrimmedArgKey])
end

--------------------------------------------------------------------------
-- Test valueFunc
--------------------------------------------------------------------------

function suite:testValueFunc()
local args = suite.getDefaultArgs{valueFunc = d.defaultValueFunc}
self:assertEquals(d.valueFuncValue, args['some random key: sdfaliwyda'])
end

function suite:testValueFuncPrecedence()
local args = suite.getDefaultArgs{
trim = false,
removeBlanks = false,
valueFunc = d.defaultValueFunc
}
self:assertEquals(d.valueFuncValue, args[1])
self:assertEquals(d.valueFuncValue, args['some random key: gekjabawyvy'])
end

function suite:testValueFuncKey()
local args = suite.getDefaultArgs{valueFunc = function(key, value)
return 'valueFunc key: '.. key
end}
self:assertEquals('valueFunc key: foo', args.foo)
end

function suite:testValueFuncValue()
local args = suite.getDefaultArgs{valueFunc = function(key, value)
return 'valueFunc value: '.. value
end}
self:assertEquals(
'valueFunc value: ' .. d.uniqueFrameArg,
args[d.uniqueFrameArgKey]
)
end

--------------------------------------------------------------------------
-- Test adding new arguments
--------------------------------------------------------------------------

function suite:testAddingNewArgs()
local args = suite.getDefaultArgs()
self:assertEquals(nil, args.newKey)
args.newKey = 'some new key'
self:assertEquals('some new key', args.newKey)
end

function suite:testAddingNewBlankArgs()
local args = suite.getDefaultArgs()
self:assertEquals(nil, args.newKey)
args.newKey = ''
self:assertEquals('', args.newKey)
end

function suite:testAddingNewSpacesArgs()
local args = suite.getDefaultArgs()
self:assertEquals(nil, args.newKey)
args.newKey = ' '
self:assertEquals(' ', args.newKey)
end

function suite:testOverwriting()
local args = suite.getDefaultArgs()
self:assertEquals(d.firstFrameArg, args[1])
args[1] = 'a new first frame argument'
self:assertEquals('a new first frame argument', args[1])
end

function suite:testOverwritingWithNil()
local args = suite.getDefaultArgs()
self:assertEquals(d.firstFrameArg, args[1])
args[1] = nil
self:assertEquals(nil, args[1])
end

function suite:testOverwritingWithBlank()
local args = suite.getDefaultArgs()
self:assertEquals(d.firstFrameArg, args[1])
args[1] = ''
self:assertEquals('', args[1])
end

function suite:testOverwritingWithSpaces()
local args = suite.getDefaultArgs()
self:assertEquals(d.firstFrameArg, args[1])
args[1] = ' '
self:assertEquals(' ', args[1])
end

function suite:testReadOnly()
local args = suite.getDefaultArgs{readOnly = true}
local function testFunc()
args.newKey = 'some new value'
end
self:assertError(testFunc)
end

function suite:testNoOverwriteExistingKey()
local args = suite.getDefaultArgs{noOverwrite = true}
self:assertEquals(d.firstFrameArg, args[1])
local function testFunc()
args[1] = 'a new first frame argument'
end
self:assertError(testFunc)
end

function suite:testNoOverwriteNewKey()
local args = suite.getDefaultArgs{noOverwrite = true}
self:assertEquals(nil, args.newKey)
args.newKey = 'some new value'
self:assertEquals('some new value', args.newKey)
end

--------------------------------------------------------------------------
-- Test bad input
--------------------------------------------------------------------------

function suite:testBadFrameInput()
self:assertError(getArgs, 'foo')
self:assertError(getArgs, 9)
self:assertError(getArgs, true)
self:assertError(getArgs, function() return true end)
end

function suite:testBadOptionsInput()
self:assertError(getArgs, {}, 'foo')
self:assertError(getArgs, {}, 9)
self:assertError(getArgs, {}, true)
self:assertError(getArgs, {}, function() return true end)
end

function suite:testBadValueFuncInput()
self:assertError(getArgs, {}, {valueFunc = 'foo'})
self:assertError(getArgs, {}, {valueFunc = 9})
self:assertError(getArgs, {}, {valueFunc = true})
self:assertError(getArgs, {}, {valueFunc = {}})
end

--------------------------------------------------------------------------
-- Test iterator metamethods
--------------------------------------------------------------------------

function suite:testPairs()
local args = getArgs{'foo', 'bar', baz = 'qux'}
self:assertNumberOfIterations(3, pairs, args)
end

function suite:testIpairs()
local args = getArgs{'foo', 'bar', baz = 'qux'}
self:assertNumberOfIterations(2, ipairs, args)
end

function suite:testNoNilsinPairs()
-- Test that when we use pairs, we don't iterate over any nil values
-- that have been memoized.
local args = getArgs{''}
local temp = args[1] -- Memoizes the nil
self:assertNumberOfIterations(0, pairs, args)
end

function suite:testNoNilsinIpairs()
-- Test that when we use ipairs, we don't iterate over any nil values
-- that have been memoized.
local args = getArgs{''}
local temp = args[1] -- Memoizes the nil
self:assertNumberOfIterations(0, ipairs, args)
end

function suite:testDeletedArgsInPairs()
-- Test that when we use pairs, we don't iterate over any values that have
-- been explicitly set to nil.
local args = getArgs{'foo'}
args[1] = nil
self:assertNumberOfIterations(0, pairs, args)
end

function suite:testDeletedArgsInIpairs()
-- Test that when we use ipairs, we don't iterate over any values that have
-- been explicitly set to nil.
local args = getArgs{'foo'}
args[1] = nil
self:assertNumberOfIterations(0, ipairs, args)
end

function suite:testNoNilsInPairsAfterIndex()
-- Test that when we use pairs, we don't iterate over any nils that
-- might have been memoized after a value that is not present in the
-- original args table is indexed.
local args = getArgs{}
local temp = args.someRandomValue -- Memoizes the nil
self:assertNumberOfIterations(0, pairs, args)
end

function suite:testNoNilsInPairsAfterNewindex()
-- Test that when we use pairs, we don't iterate over any nils that
-- might have been memoized after a value that is not present in the
-- original args table is added to the args table.
local args = getArgs{}
args.newKey = nil -- The nil is memoized
self:assertNumberOfIterations(0, pairs, args)
end

function suite:testNoTableLengthChangeWhileIterating()
-- Test that the number of arguments doesn't change if we index the
-- args table while iterating.
-- (Note that the equivalent test is not needed for new arg table
-- indexes, as that would be a user error - doing so produces
-- undetermined behaviour in Lua's next() function.)
local args = getArgs{'foo', 'bar', baz = 'qux'}
self:assertNumberOfIterations(3, pairs, args)
for k, v in pairs(args) do
local temp = args[k .. 'foo']
end
self:assertNumberOfIterations(3, pairs, args)
end

function suite:testPairsPrecedenceWithWhitespace()
local frame, parent = suite.getFrames(
d.frameTitle,
{' '},
d.parentTitle,
{d.firstParentArg}
)
local args = getArgs(frame)
local actual
for k, v in pairs(args) do
actual = v
end
self:assertEquals(d.firstParentArg, actual)
-- Check that we have actually iterated.
self:assertNumberOfIterations(1, pairs, args)
end

function suite:testPairsPrecedenceWithNil()
local frame, parent = suite.getFrames(
d.frameTitle,
{},
d.parentTitle,
{d.firstParentArg}
)
local args = getArgs(frame)
local actual
for k, v in pairs(args) do
actual = v
end
self:assertEquals(d.firstParentArg, actual)
-- Check that we have actually iterated.
self:assertNumberOfIterations(1, pairs, args)
end

function suite:testIpairsEarlyExit()
local mt = {}
function mt.__index(t, k)
if k == 1 then
return 'foo'
elseif k == 2 then
return 'bar'
elseif k == 3 then
error('Expanded argument 3 unnecessarily')
end
end
function mt.__pairs(t)
error('Called pairs unnecessarily')
end
function mt.__ipairs(t)
-- Works just like the default ipairs, except respecting __index
return function(t, i)
local v = t[i + 1]
if v ~= nil then
return i + 1, v
end
end, t, 0
end
local args = getArgs(setmetatable({}, mt))
for k,v in ipairs(args) do
if v == 'bar' then
break
end
end
end

--------------------------------------------------------------------------
-- Test argument translation
--------------------------------------------------------------------------

function suite:testTranslationIndex()
local args = getArgs({F00 = 'one', ['8@r'] = 'two', ['8@z'] = 'three', qUx = 'four', foo = 'nope', untranslated = 'yep'}, {translate = d.translate})
self:assertEquals('one', args.foo)
self:assertEquals('two', args.bar)
self:assertEquals('three', args.baz)
self:assertEquals('four', args.qux)
self:assertEquals('yep', args.untranslated)
end

function suite:testTranslationPairsWithAutoBacktranslate()
local args = getArgs({F00 = 'one', ['8@r'] = 'two', ['8@z'] = 'three', qUx = 'four', foo = 'nope', untranslated = 'yep'}, {translate = d.translate})
local cleanArgs = {}
for k,v in pairs(args) do
cleanArgs[k] = v
end
self:assertDeepEquals(
{
foo = 'one',
bar = 'two',
baz = 'three',
qux = 'four',
untranslated = 'yep'
},
cleanArgs
)
end

function suite:testTranslationPairsWithBacktranslate()
local args = getArgs({F00 = 'one', ['8@r'] = 'two', ['8@z'] = 'three', qUx = 'four', foo = 'nope', untranslated = 'yep'}, {translate = d.translate, backtranslate = {F00 = 'foo'}})
local cleanArgs = {}
for k,v in pairs(args) do
cleanArgs[k] = v
end
self:assertDeepEquals(
{
foo = 'one',
['8@r'] = 'two',
['8@z'] = 'three',
qUx = 'four',
untranslated = 'yep'
},
cleanArgs
)
end

function suite:testTranslationPairsWithoutBacktranslate()
local args = getArgs({F00 = 'one', ['8@r'] = 'two', ['8@z'] = 'three', qUx = 'four', foo = 'nope', untranslated = 'yep'}, {translate = d.translate, backtranslate = false})
local cleanArgs = {}
for k,v in pairs(args) do
cleanArgs[k] = v
end
self:assertDeepEquals(
{
F00 = 'one',
['8@r'] = 'two',
['8@z'] = 'three',
qUx = 'four',
foo = 'nope',
untranslated = 'yep'
},
cleanArgs
)
end

function suite:testTranslationNewindex()
local args = getArgs({F00 = 'one', ['8@r'] = 'two', ['8@z'] = 'three', qUx = 'four', foo = 'nope', untranslated = 'yep'}, {translate = d.translate, backtranslate = false})
args.foo = 'changed1'
args.untranslated = 'changed2'
local cleanArgs = {}
for k,v in pairs(args) do
cleanArgs[k] = v
end
self:assertDeepEquals(
{
F00 = 'changed1',
['8@r'] = 'two',
['8@z'] = 'three',
qUx = 'four',
foo = 'nope',
untranslated = 'changed2'
},
cleanArgs
)
end

function suite:test_argument()
local currentFrame = mw.getCurrentFrame()
currentFrame.args[5] = 555;
local args = getArgs(currentFrame)
self:assertEquals('nil', type(args.foo))
end

return suite

Modul:Arguments/testcases - Historie editací

Maska: naimportována 1 revize

Module>Capankajsmilyo: +