Difference between revisions of "Module:Arguments/testcases"

From blackwiki
Jump to navigation Jump to search
blackwiki>Mr. Stradivarius
(finish trimming and blank removal tests)
blackwiki>Mr. Stradivarius
(finish converting tests)
Line 22: Line 22:
 
-- Trimming and whitespace values.
 
-- Trimming and whitespace values.
 
-- Whitespace gets trimmed from named parameters, so keys for these need
 
-- Whitespace gets trimmed from named parameters, so keys for these need
-- to be numbers
+
-- to be numbers to make this a proper test.
 
d.blankArg = ''
 
d.blankArg = ''
 
d.blankArgKey = 100  
 
d.blankArgKey = 100  
Line 69: Line 69:
 
end
 
end
  
function suite:assertHtmlError(s)
+
function suite:assertError(func, ...)
self:assertTrue(s:find('^<strong class="error">.*</strong>$'))
+
-- 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
 
end
  
Line 177: Line 180:
 
end
 
end
  
--[=[
 
 
--------------------------------------------------------------------------
 
--------------------------------------------------------------------------
-- Test default arg writing
+
-- Test adding new arguments
 
--------------------------------------------------------------------------
 
--------------------------------------------------------------------------
  
suite.defaultArgWriting = suite.makeInvokeFunction(arbitraryKey, nil, valueWrittenToArgs)
+
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:testDefaultArgWriting()
+
function suite:testAddingNewBlankArgs()
local arg = suite.getDefaultTemplateExpansion('defaultArgWriting')
+
local args = suite.getDefaultArgs()
self:assertEquals(valueWrittenToArgs, arg)
+
self:assertEquals(nil, args.newKey)
 +
args.newKey = ''
 +
self:assertEquals('', args.newKey)
 
end
 
end
  
--------------------------------------------------------------------------
+
function suite:testAddingNewSpacesArgs()
-- Test default arg overwrite
+
local args = suite.getDefaultArgs()
--------------------------------------------------------------------------
+
self:assertEquals(nil, args.newKey)
 +
args.newKey = ' '
 +
self:assertEquals(' ', args.newKey)
 +
end
  
suite.defaultArgOverwrite = suite.makeInvokeFunction(keyWithPriority, nil, overwrittenValue)
+
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:testDefaultArgOverwrite()
+
function suite:testOverwritingWithNil()
local arg = suite.getDefaultTemplateExpansion('defaultArgOverwrite')
+
local args = suite.getDefaultArgs()
self:assertEquals(overwrittenValue, arg)
+
self:assertEquals(d.firstFrameArg, args[1])
 +
args[1] = nil
 +
self:assertEquals(nil, args[1])
 
end
 
end
  
--------------------------------------------------------------------------
+
function suite:testOverwritingWithBlank()
-- Test read only
+
local args = suite.getDefaultArgs()
--------------------------------------------------------------------------
+
self:assertEquals(d.firstFrameArg, args[1])
 +
args[1] = ''
 +
self:assertEquals('', args[1])
 +
end
  
suite.readOnly = suite.makeInvokeFunction(arbitraryKey, {readOnly = true}, valueWrittenToArgs)
+
function suite:testOverwritingWithSpaces()
 +
local args = suite.getDefaultArgs()
 +
self:assertEquals(d.firstFrameArg, args[1])
 +
args[1] = ' '
 +
self:assertEquals(' ', args[1])
 +
end
  
 
function suite:testReadOnly()
 
function suite:testReadOnly()
local arg = suite.getDefaultTemplateExpansion('readOnly')
+
local args = suite.getDefaultArgs{readOnly = true}
self:assertHtmlError(arg)
+
local function testFunc()
 +
args.newKey = 'some new value'
 +
end
 +
self:assertError(testFunc)
 
end
 
end
  
--------------------------------------------------------------------------
+
function suite:testNoOverwriteExistingKey()
-- Test no overwrite
+
local args = suite.getDefaultArgs{noOverwrite = true}
--------------------------------------------------------------------------
+
self:assertEquals(d.firstFrameArg, args[1])
 
+
local function testFunc()
suite.noOverwrite = suite.makeInvokeFunction(keyWithPriority, {noOverwrite = true}, overwrittenValue)
+
args[1] = 'a new first frame argument'
 
+
end
function suite:testNoOverwrite()
+
self:assertError(testFunc)
local arg = suite.getDefaultTemplateExpansion('noOverwrite')
 
self:assertHtmlError(arg)
 
 
end
 
end
  
--------------------------------------------------------------------------
+
function suite:testNoOverwriteNewKey()
-- Test making existing arg nil
+
local args = suite.getDefaultArgs{noOverwrite = true}
--------------------------------------------------------------------------
+
self:assertEquals(nil, args.newKey)
 
+
args.newKey = 'some new value'
function suite:testMakeExistingArgNil()
+
self:assertEquals('some new value', args.newKey)
 
end
 
end
 
--]=]
 
  
 
return suite
 
return suite

Revision as of 11:55, 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.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.randomKey = 'a random key: oesidfk374g'

--------------------------------------------------------------------------
-- 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,
		[d.blankArgKey] = d.blankArg,
		[d.spacesArgKey] = d.spacesArg,
		[d.untrimmedArgKey] = d.untrimmedArg
	}
	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

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

--------------------------------------------------------------------------
-- Test 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

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

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

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 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[d.randomKey])
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[d.randomKey])
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

return suite