Difference between revisions of "Module:Arguments/testcases"

From blackwiki
Jump to navigation Jump to search
blackwiki>Mr. Stradivarius
m (comment grammar fix)
blackwiki>Mr. Stradivarius
(start rewriting the tests)
Line 3: Line 3:
 
local suite = ScribuntoUnit:new()
 
local suite = ScribuntoUnit:new()
  
-- Constants
+
--------------------------------------------------------------------------
 
+
-- Default values
local defaultArgs = {}
+
--------------------------------------------------------------------------
defaultArgs.invoke = 'firstInvokeArg'
 
defaultArgs[1] = 'firstTemplateArg'
 
defaultArgs[2] = 'secondTemplateArg'
 
  
local keyWithPriority = 2 -- Key for a template parameter that won't be overwritten when it is passed to #invoke.
+
local d = {}
local nilArg = 'nilArg'
+
d.frameTitle = 'Frame title'
local arbitraryKey = 'someArbitraryKey'
+
d.firstFrameArg = 'first frame argument'
local overwrittenValue = 'overwrittenValue'
+
d.parentTitle = 'Parent title'
local valueWrittenToArgs = 'valueWrittenToArgs'
+
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'
  
 
--------------------------------------------------------------------------
 
--------------------------------------------------------------------------
Line 20: Line 22:
 
--------------------------------------------------------------------------
 
--------------------------------------------------------------------------
  
------------------ Template invocations used by the module --------------------
+
function suite.getFrames(frameTitle, frameArgs, parentTitle, parentArgs)
-- Module talk:Arguments/testInvoke:
+
local currentFrame = mw.getCurrentFrame()
-- {{#invoke:arguments/testcases|{{{function|}}}|firstInvokeArg}}
+
local parent = currentFrame:newChild{title = parentTitle, args = parentArgs}
-- Module talk:Arguments/testTemplate:
+
local frame = parent:newChild{title = frameTitle, args = frameArgs}
-- {{Module talk:Arguments/testInvoke|{{{1|}}}|{{{2|}}}|blank=|function={{{function|}}}}}
+
return frame, parent
 
 
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
 
end
  
function suite.getDefaultTemplateExpansion(funcName)
+
function suite.getDefaultFrames()
return suite.expandTestTemplate(funcName, defaultArgs[1], defaultArgs[2])
+
local frameTitle = d.frameTitle
 +
local frameArgs = {
 +
d.firstFrameArg,
 +
[d.uniqueFrameArgKey] = d.uniqueFrameArg
 +
}
 +
local parentTitle = d.parentTitle
 +
local parentArgs = {
 +
d.firstParentArg,
 +
d.secondParentArg,
 +
[d.uniqueParentArgKey] = d.uniqueParentArg
 +
}
 +
return suite.getFrames(frameTitle, frameArgs, parentTitle, parentArgs)
 
end
 
end
  
function suite.getInvocation(funcName)
+
function suite.getDefaultArgs(options)
local frame = mw.getCurrentFrame()
+
local frame, parent = suite.getDefaultFrames()
local val = frame:preprocess('{{Module talk:Arguments/testInvoke|function=' .. funcName .. '}}')
+
local args = getArgs(frame, options)
return val
+
return args
 
end
 
end
  
function suite.getDefaultExpansions(testcaseName)
+
--------------------------------------------------------------------------
local first = suite.getDefaultTemplateExpansion(testcaseName .. 'First')
+
-- Extra assert functions
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
 
  
 
function suite:assertHtmlError(s)
 
function suite:assertHtmlError(s)
Line 76: Line 61:
 
-- Test default precedence
 
-- Test default precedence
 
--------------------------------------------------------------------------
 
--------------------------------------------------------------------------
 
suite.makeArgInvokeFunctions('defaultPrecedence')
 
  
 
function suite:testDefaultPrecedence()
 
function suite:testDefaultPrecedence()
local first, second, invoke = suite.getDefaultExpansions('defaultPrecedence')
+
local args = suite.getDefaultArgs()
self:assertEquals(defaultArgs.invoke, first)
+
self:assertEquals(d.firstFrameArg, args[1])
self:assertEquals(defaultArgs[2], second)
+
self:assertEquals(d.secondParentArg, args[2])
self:assertEquals(defaultArgs.invoke, invoke)
+
self:assertEquals(d.uniqueFrameArg, args[d.uniqueFrameArgKey])
 +
self:assertEquals(d.uniqueParentArg, args[d.uniqueParentArgKey])
 
end
 
end
  
Line 89: Line 73:
 
-- Test parent first
 
-- Test parent first
 
--------------------------------------------------------------------------
 
--------------------------------------------------------------------------
 
suite.makeArgInvokeFunctions('parentFirst', {parentFirst = true})
 
  
 
function suite:testParentFirst()
 
function suite:testParentFirst()
local first, second, invoke = suite.getDefaultExpansions('parentFirst')
+
local args = suite.getDefaultArgs{parentFirst = true}
self:assertEquals(defaultArgs[1], first)
+
self:assertEquals(d.firstParentArg, args[1])
self:assertEquals(defaultArgs[2], second)
+
self:assertEquals(d.secondParentArg, args[2])
self:assertEquals(defaultArgs.invoke, invoke)
+
self:assertEquals(d.uniqueFrameArg, args[d.uniqueFrameArgKey])
 +
self:assertEquals(d.uniqueParentArg, args[d.uniqueParentArgKey])
 
end
 
end
 +
  
 
--------------------------------------------------------------------------
 
--------------------------------------------------------------------------
 
-- Test parent only
 
-- Test parent only
 
--------------------------------------------------------------------------
 
--------------------------------------------------------------------------
 
suite.makeArgInvokeFunctions('parentOnly', {parentOnly = true})
 
  
 
function suite:testParentOnly()
 
function suite:testParentOnly()
local first, second, invoke = suite.getDefaultExpansions('parentOnly')
+
local args = suite.getDefaultArgs{parentOnly = true}
self:assertEquals(defaultArgs[1], first)
+
self:assertEquals(d.firstParentArg, args[1])
self:assertEquals(defaultArgs[2], second)
+
self:assertEquals(d.secondParentArg, args[2])
self:assertEquals(nilArg, invoke)
+
self:assertEquals(nil, args[d.uniqueFrameArgKey])
 +
self:assertEquals(d.uniqueParentArg, args[d.uniqueParentArgKey])
 
end
 
end
  
Line 115: Line 98:
 
-- Test frame only
 
-- Test frame only
 
--------------------------------------------------------------------------
 
--------------------------------------------------------------------------
 
suite.makeArgInvokeFunctions('frameOnly', {frameOnly = true})
 
  
 
function suite:testFrameOnly()
 
function suite:testFrameOnly()
local first, second, invoke = suite.getDefaultExpansions('frameOnly')
+
local args = suite.getDefaultArgs{frameOnly = true}
self:assertEquals(defaultArgs.invoke, first)
+
self:assertEquals(d.firstFrameArg, args[1])
self:assertEquals(nilArg, second)
+
self:assertEquals(nil, args[2])
self:assertEquals(defaultArgs.invoke, invoke)
+
self:assertEquals(d.uniqueFrameArg, args[d.uniqueFrameArgKey])
 +
self:assertEquals(nil, args[d.uniqueParentArgKey])
 
end
 
end
  
 +
--[=[
 
--------------------------------------------------------------------------
 
--------------------------------------------------------------------------
 
-- Test default trimming
 
-- Test default trimming
Line 257: Line 240:
 
self:assertHtmlError(arg)
 
self:assertHtmlError(arg)
 
end
 
end
 +
 +
--------------------------------------------------------------------------
 +
-- Test making existing arg nil
 +
--------------------------------------------------------------------------
 +
 +
function suite:testMakeExistingArgNil()
 +
end
 +
 +
--]=]
  
 
return suite
 
return suite

Revision as of 10:30, 17 April 2014

Documentation for this module may be created at Module:Arguments/testcases/doc

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

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

local d = {} 
d.frameTitle = 'Frame title'
d.firstFrameArg = 'first frame argument'
d.parentTitle = 'Parent title'
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'

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

function suite.getFrames(frameTitle, frameArgs, parentTitle, parentArgs)
	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.getDefaultFrames()
	local frameTitle = d.frameTitle
	local frameArgs = {
		d.firstFrameArg,
		[d.uniqueFrameArgKey] = d.uniqueFrameArg
	}
	local parentTitle = d.parentTitle
	local parentArgs = {
		d.firstParentArg,
		d.secondParentArg,
		[d.uniqueParentArgKey] = d.uniqueParentArg
	}
	return suite.getFrames(frameTitle, frameArgs, parentTitle, parentArgs)
end

function suite.getDefaultArgs(options)
	local frame, parent = suite.getDefaultFrames()
	local args = getArgs(frame, options)
	return args
end

--------------------------------------------------------------------------
-- Extra assert functions
--------------------------------------------------------------------------

function suite:assertHtmlError(s)
	self:assertTrue(s:find('^<strong class="error">.*</strong>$'))
end

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

function suite:testDefaultPrecedence()
	local args = suite.getDefaultArgs()
	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

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

function suite:testParentFirst()
	local args = suite.getDefaultArgs{parentFirst = true}
	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


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

function suite:testParentOnly()
	local args = suite.getDefaultArgs{parentOnly = true}
	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

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

function suite:testFrameOnly()
	local args = suite.getDefaultArgs{frameOnly = true}
	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

--[=[
--------------------------------------------------------------------------
-- 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: ' .. tostring(keyWithPriority), 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:assertHtmlError(arg)
end

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

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

function suite:testNoOverwrite()
	local arg = suite.getDefaultTemplateExpansion('noOverwrite')
	self:assertHtmlError(arg)
end

--------------------------------------------------------------------------
-- Test making existing arg nil
--------------------------------------------------------------------------

function suite:testMakeExistingArgNil()
end

--]=]

return suite