Module:Arguments/testcases

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

-- Constants

local defaultArgs = {}
defaultArgs.invoke = 'firstInvokeArg'
defaultArgs[1] = 'firstTemplateArg'
defaultArgs[2] = 'secondTemplateArg'

local keyWithPriority = 2 -- Key for the a template parameter that won't be overwritten when it is passed to #invoke.
local nilArg = 'nilArg'
local arbitraryKey = 'someArbitraryKey'
local overwrittenValue = 'overwrittenValue'
local valueWrittenToArgs = 'valueWrittenToArgs'

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

------------------ Template invocations used by the module --------------------
-- Module talk:Arguments/testInvoke:
-- {{#invoke:arguments/testcases|{{{function|}}}|firstInvokeArg}}
-- Module talk:Arguments/testTemplate:
-- {{Module talk:Arguments/testInvoke|{{{1|}}}|{{{2|}}}|blank=|function={{{function|}}}}}

function suite.expandTestTemplate(funcName, para1, para2)
	local frame = mw.getCurrentFrame()
	local val = frame:preprocess('{{Module talk:Arguments/testTemplate|' .. (para1 or '') .. '|' .. (para2 or '') .. '|function=' .. funcName .. '}}')
	return val
end

function suite.getDefaultTemplateExpansion(funcName)
	return suite.expandTestTemplate(funcName, defaultArgs[1], defaultArgs[2])
end

function suite.getInvocation(funcName)
	local frame = mw.getCurrentFrame()
	local val = frame:preprocess('{{Module talk:Arguments/testInvoke|function=' .. funcName .. '}}')
	return val
end

function suite.getDefaultExpansions(testcaseName)
	local first = suite.getDefaultTemplateExpansion(testcaseName .. 'First')
	local second = suite.getDefaultTemplateExpansion(testcaseName .. 'Second')
	local invoke = suite.getInvocation(testcaseName .. 'First')
	return first, second, invoke
end

function suite.makeInvokeFunction(key, options, overwriteVal)
	return function (frame)
		options = options or {}
		local args = getArgs(frame, options)
		if overwriteVal then
			args[key] = overwriteVal
		end
		if args[key] ~= nil then
			return args[key]
		else
			return nilArg
		end
	end
end

function suite.makeArgInvokeFunctions(testcaseName, options)
	suite[testcaseName .. 'First'] = suite.makeInvokeFunction(1, options)
	suite[testcaseName .. 'Second'] = suite.makeInvokeFunction(2, options)
end

--------------------------------------------------------------------------
-- Test default precedence
--------------------------------------------------------------------------

suite.makeArgInvokeFunctions('defaultPrecedence')

function suite:testDefaultPrecedence()
	local first, second, invoke = suite.getDefaultExpansions('defaultPrecedence')
	self:assertEquals(defaultArgs.invoke, first)
	self:assertEquals(defaultArgs[2], second)
	self:assertEquals(defaultArgs.invoke, invoke)
end

--------------------------------------------------------------------------
-- Test parent first
--------------------------------------------------------------------------

suite.makeArgInvokeFunctions('parentFirst', {parentFirst = true})

function suite:testParentFirst()
	local first, second, invoke = suite.getDefaultExpansions('parentFirst')
	self:assertEquals(defaultArgs[1], first)
	self:assertEquals(defaultArgs[2], second)
	self:assertEquals(defaultArgs.invoke, invoke)
end

--------------------------------------------------------------------------
-- Test parent only
--------------------------------------------------------------------------

suite.makeArgInvokeFunctions('parentOnly', {parentOnly = true})

function suite:testParentOnly()
	local first, second, invoke = suite.getDefaultExpansions('parentOnly')
	self:assertEquals(defaultArgs[1], first)
	self:assertEquals(defaultArgs[2], second)
	self:assertEquals(nilArg, invoke)
end

--------------------------------------------------------------------------
-- Test frame only
--------------------------------------------------------------------------

suite.makeArgInvokeFunctions('frameOnly', {frameOnly = true})

function suite:testFrameOnly()
	local first, second, invoke = suite.getDefaultExpansions('frameOnly')
	self:assertEquals(defaultArgs.invoke, first)
	self:assertEquals(nilArg, second)
	self:assertEquals(defaultArgs.invoke, invoke)
end

--------------------------------------------------------------------------
-- Test default trimming
--------------------------------------------------------------------------

suite.defaultTrimming = suite.makeInvokeFunction(keyWithPriority)

function suite:testDefaultTrimming()
	local arg = suite.expandTestTemplate('defaultTrimming', nil, '  argWithPadding  ')
	self:assertEquals('argWithPadding', arg)
end

--------------------------------------------------------------------------
-- Test no trimming
--------------------------------------------------------------------------

suite.noTrimming = suite.makeInvokeFunction(keyWithPriority, {trim = false})

function suite:testNoTrimming()
	local arg = suite.expandTestTemplate('noTrimming', nil, '  argWithPadding  ')
	self:assertEquals('  argWithPadding  ', arg)
end

--------------------------------------------------------------------------
-- Test default blank removal
--------------------------------------------------------------------------

suite.defaultBlankRemoval = suite.makeInvokeFunction(keyWithPriority)

function suite:testDefaultBlankRemoval()
	local arg = suite.expandTestTemplate('defaultBlankRemoval', nil, '')
	self:assertEquals(nilArg, arg)
end

--------------------------------------------------------------------------
-- Test no blank removal
--------------------------------------------------------------------------

suite.noBlankRemoval = suite.makeInvokeFunction(keyWithPriority, {removeBlanks = false})

function suite:testNoBlankRemoval()
	local arg = suite.expandTestTemplate('noBlankRemoval', nil, '')
	self:assertEquals('', arg)
end

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

suite.valueFunc = suite.makeInvokeFunction(keyWithPriority, {valueFunc = function () return 'valueFuncValue' end})

function suite:testValueFunc()
	local arg = suite.getDefaultTemplateExpansion('valueFunc')
	self:assertEquals('valueFuncValue', arg)
end

--------------------------------------------------------------------------
-- Test valueFunc key
--------------------------------------------------------------------------

suite.valueFuncKey = suite.makeInvokeFunction(keyWithPriority, {
	valueFunc = function (key, val)
		if val then
			return 'valueFuncKey: ' .. tostring(key)
		end
	end
})

function suite:testValueFuncKey()
	local arg = suite.getDefaultTemplateExpansion('valueFuncKey')
	self:assertEquals('valueFuncKey: 2', arg)
end

--------------------------------------------------------------------------
-- Test valueFunc value
--------------------------------------------------------------------------

suite.valueFuncValue = suite.makeInvokeFunction(keyWithPriority, {
	valueFunc = function (key, val)
		if val then
			return 'valueFuncValue: ' .. val
		end
	end
})

function suite:testValueFuncValue()
	local arg = suite.getDefaultTemplateExpansion('valueFuncValue')
	self:assertEquals('valueFuncValue: ' .. defaultArgs[2], arg)
end

--------------------------------------------------------------------------
-- Test default arg writing
--------------------------------------------------------------------------

suite.defaultArgWriting = suite.makeInvokeFunction(arbitraryKey, nil, valueWrittenToArgs)

function suite:testDefaultArgWriting()
	local arg = suite.getDefaultTemplateExpansion('defaultArgWriting')
	self:assertEquals(valueWrittenToArgs, arg)
end

--------------------------------------------------------------------------
-- Test default arg overwrite
--------------------------------------------------------------------------

suite.defaultArgOverwrite = suite.makeInvokeFunction(keyWithPriority, nil, overwrittenValue)

function suite:testDefaultArgOverwrite()
	local arg = suite.getDefaultTemplateExpansion('defaultArgOverwrite')
	self:assertEquals(overwrittenValue, arg)
end

--------------------------------------------------------------------------
-- Test read only
--------------------------------------------------------------------------

suite.readOnly = suite.makeInvokeFunction(arbitraryKey, {readOnly = true}, valueWrittenToArgs)

function suite:testReadOnly()
	local arg = suite.getDefaultTemplateExpansion('readOnly')
	self:assertEquals(nilArg, arg)
end

--------------------------------------------------------------------------
-- Test no overwrite
--------------------------------------------------------------------------

suite.noOverwrite = suite.makeInvokeFunction(keyWithPriority, {noOverwrite = true}, overwrittenValue)

function suite:testReadOnly()
	local arg = suite.getDefaultTemplateExpansion('noOverwrite')
	self:assertEquals(defaultArgs[keyWithPriority], arg)
end

return suite