Toggle search
Toggle menu
15
236
70
27.5K
Kenshi Wiki
Toggle preferences menu
Toggle personal menu
Not logged in
Your IP address will be publicly visible if you make any edits.

Module:List/testcases

From Kenshi Wiki
More actions
Refer to
Module:List


-- Unit tests for [[Module:List]]. Click talk page to run tests.

local mList = require('Module:List/sandbox')
local ScribuntoUnit = require('Module:ScribuntoUnit')
local suite = ScribuntoUnit:new()

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

local d = {}

-- Function names
d.bulletedFunc = 'bulleted'
d.unbulletedFunc = 'unbulleted'
d.horizontalFunc = 'horizontal'
d.orderedFunc = 'ordered'
d.horizontalOrderedFunc = 'horizontal_ordered'

-- List items
d.item1 = 'Foo'
d.item2 = 'Bar'
d.itemNested = '\n*Subitem 1\n*Subitem 2'  -- The leading LF must not be trimmed from such item

-- Styles and classes
d.arbitraryStyle = 'text-align: right'
d.arbitraryValue = 'some value'
d.arbitraryClass = 'someclass'
d.arbitraryClass2 = 'someclass2'
d.hlist = 'hlist'
d.plainlist = 'plainlist'
d.templatestyles_pattern = '\127[^\127]*UNIQ%-%-templatestyles%-%x+%-QINU[^\127]*\127'

-- Parameter names
d.itemStyleParam1 = 'item1_style'
d.itemValueParam1 = 'item1_value'

-- Attributes
d.arbitraryStart = '5'

-- Tracking categories
d.trackingCategory = '[[Category:List templates with deprecated parameters]]'

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

function suite:assertArrayContainsString(expected, t)
	-- This only works on arrays that only contain strings.
	local sep = '|SEPARATOR|'
	local concatenated = sep .. table.concat(t, sep) .. sep
	self:assertStringContains(sep .. expected .. sep, concatenated, true)
end

--------------------------------------------------------------------------------
-- Test makeListData
--------------------------------------------------------------------------------

function suite:testDataBlank()
	local data = mList.makeListData(d.bulletedFunc, {})
	self:assertEquals('table', type(data))
end

function suite:testDataOneItem()
	local data = mList.makeListData(d.bulletedFunc, {d.item1})
	self:assertEquals(d.item1, data.items[1].content)
end

function suite:testDataTwoItems()
	local data = mList.makeListData(d.bulletedFunc, {d.item1, d.item2})
	self:assertEquals(d.item1, data.items[1].content)
	self:assertEquals(d.item2, data.items[2].content)
end

function suite:testDataItemStyle1()
	local data = mList.makeListData(d.bulletedFunc, {d.item1, [d.itemStyleParam1] = d.arbitraryStyle})
	self:assertEquals(d.arbitraryStyle, data.items[1].style)
end

function suite:testDataItemStyle1NoContent()
	local data = mList.makeListData(d.bulletedFunc, {[d.itemStyleParam1] = d.arbitraryStyle})
	self:assertEquals(nil, data.items[1])
end

function suite:testDataItemValue1()
	local data = mList.makeListData(d.bulletedFunc, {d.item1, [d.itemValueParam1] = d.arbitraryValue})
	self:assertEquals(d.arbitraryValue, data.items[1].value)
end

function suite:testDataItemValue1NoContent()
	local data = mList.makeListData(d.bulletedFunc, {[d.itemValueParam1] = d.arbitraryValue})
	self:assertEquals(nil, data.items[1])
end

function suite:testDataItemStyle()
	local data = mList.makeListData(d.bulletedFunc, {item_style = d.arbitraryStyle})
	self:assertEquals(d.arbitraryStyle, data.itemStyle)
end

function suite:testDataListStyle()
	local data = mList.makeListData(d.bulletedFunc, {list_style = d.arbitraryStyle})
	self:assertEquals(d.arbitraryStyle, data.listStyle)
end

function suite:testDataStart()
	local data = mList.makeListData(d.bulletedFunc, {start = d.arbitraryStart})
	self:assertEquals(d.arbitraryStart, data.start)
end

function suite:testDataHorizontalNumberingFix()
	local data = mList.makeListData(d.horizontalOrderedFunc, {start = '5'})
	self:assertEquals('5', data.start)
	self:assertEquals('listitem 4', data.counterReset)
end

function suite:testDataHorizontalNumberingFixBadInput()
	local data = mList.makeListData(d.horizontalOrderedFunc, {start = 'foo'})
	self:assertEquals('foo', data.start)
	self:assertEquals(nil, data.counterReset)
end

function suite:testDataHorizontalNumberingFixNumberInput()
	local data = mList.makeListData(d.horizontalOrderedFunc, {start = 6})
	self:assertEquals(6, data.start)
	self:assertEquals('listitem 5', data.counterReset)
end

function suite:testDataListTag()
	self:assertEquals('ul', mList.makeListData(d.bulletedFunc, {}).listTag)
	self:assertEquals('ul', mList.makeListData(d.horizontalFunc, {}).listTag)
	self:assertEquals('ul', mList.makeListData(d.unbulletedFunc, {}).listTag)
	self:assertEquals('ol', mList.makeListData(d.orderedFunc, {}).listTag)
	self:assertEquals('ol', mList.makeListData(d.horizontalOrderedFunc, {}).listTag)
end

function suite:testDataListStyleType()
	self:assertEquals('foo', mList.makeListData(d.orderedFunc, {list_style_type = 'foo'}).listStyleType)
	self:assertEquals('foo', mList.makeListData(d.horizontalOrderedFunc, {list_style_type = 'foo'}).listStyleType)
	self:assertEquals(nil, mList.makeListData(d.bulletedFunc, {list_style_type = 'foo'}).listStyleType)
end

function suite:testDataListStyleTypeAltSyntax()
	self:assertEquals('foo', mList.makeListData(d.orderedFunc, {['list-style-type'] = 'foo'}).listStyleType)
	self:assertEquals('foo', mList.makeListData(d.horizontalOrderedFunc, {['list-style-type'] = 'foo'}).listStyleType)
	self:assertEquals(nil, mList.makeListData(d.bulletedFunc, {['list-style-type'] = 'foo'}).listStyleType)
end

function suite:testDataValidType()
	self:assertEquals('1', mList.makeListData(d.orderedFunc, {type = '1'}).type)
	self:assertEquals('A', mList.makeListData(d.orderedFunc, {type = 'A'}).type)
	self:assertEquals('a', mList.makeListData(d.orderedFunc, {type = 'a'}).type)
	self:assertEquals('I', mList.makeListData(d.orderedFunc, {type = 'I'}).type)
	self:assertEquals('i', mList.makeListData(d.orderedFunc, {type = 'i'}).type)
end

function suite:testDataInvalidType()
	local data = mList.makeListData(d.orderedFunc, {type = 'foo'})
	self:assertEquals(nil, data.type)
	self:assertEquals('foo', data.listStyleType)
end

function suite:testDataTypeByListType()
	self:assertEquals('1', mList.makeListData(d.orderedFunc, {type = '1'}).type)
	self:assertEquals('1', mList.makeListData(d.horizontalOrderedFunc, {type = '1'}).type)
	self:assertEquals(nil, mList.makeListData(d.bulletedFunc, {type = '1'}).type)
end

function suite:testDataIndent()
	self:assertEquals('1.6em', mList.makeListData(d.horizontalFunc, {indent = 1}).marginLeft)
	self:assertEquals('3.2em', mList.makeListData(d.horizontalFunc, {indent = 2}).marginLeft)
	self:assertEquals('1.6em', mList.makeListData(d.horizontalFunc, {indent = '1'}).marginLeft)
	self:assertEquals(nil, mList.makeListData(d.horizontalFunc, {}).marginLeft)
end

function suite:testDataIndentByListType()
	self:assertEquals('1.6em', mList.makeListData(d.horizontalFunc, {indent = 1}).marginLeft)
	self:assertEquals('1.6em', mList.makeListData(d.horizontalOrderedFunc, {indent = 1}).marginLeft)
	self:assertEquals(nil, mList.makeListData(d.bulletedFunc, {indent = 1}).marginLeft)
	self:assertEquals(nil, mList.makeListData(d.unbulletedFunc, {indent = 1}).marginLeft)
	self:assertEquals(nil, mList.makeListData(d.orderedFunc, {indent = 1}).marginLeft)
end

function suite:testDataStyle()
	self:assertEquals(d.arbitraryStyle, mList.makeListData(d.horizontalFunc, {style = d.arbitraryStyle}).style)
end

function suite:testDataClass()
	self:assertArrayContainsString(d.arbitraryClass, mList.makeListData(d.bulletedFunc, {class = d.arbitraryClass}).classes)
end

function suite:testDataListTypeClasses()
	self:assertArrayContainsString(d.hlist, mList.makeListData(d.horizontalFunc, {}).classes)
	self:assertArrayContainsString(d.hlist, mList.makeListData(d.horizontalOrderedFunc, {}).classes)
	self:assertArrayContainsString(d.plainlist, mList.makeListData(d.unbulletedFunc, {}).classes)
end

--------------------------------------------------------------------------------
-- Test deprecated parameters
--------------------------------------------------------------------------------

function suite:testDeprecatedItemStyle1()
	local data = mList.makeListData(d.bulletedFunc, {d.item1, item_style1 = d.arbitraryStyle})
	self:assertEquals(d.arbitraryStyle, data.items[1].style)
end

function suite:testDeprecatedItemStyle1NoContent()
	local data = mList.makeListData(d.bulletedFunc, {item_style1 = d.arbitraryStyle})
	self:assertEquals(nil, data.items[1])
end

function suite:testDeprecatedValueStyle1()
	local data = mList.makeListData(d.bulletedFunc, {d.item1, item_value1 = d.arbitraryStyle})
	self:assertEquals(d.arbitraryStyle, data.items[1].value)
end

function suite:testDeprecatedValueStyle1NoContent()
	local data = mList.makeListData(d.bulletedFunc, {item_value1 = d.arbitraryStyle})
	self:assertEquals(nil, data.items[1])
end

--------------------------------------------------------------------------------
-- Test tracking categories
--------------------------------------------------------------------------------

function suite:testTrackingCategoriesItem1Style()
	local result = mList.renderTrackingCategories{item1_style = d.arbitraryStyle}
	self:assertEquals('', result)
end

function suite:testTrackingCategoriesItemStyle1()
	local result = mList.renderTrackingCategories{item_style1 = d.arbitraryStyle}
	self:assertEquals(d.trackingCategory, result)
end

function suite:testTrackingCategoriesItemStyle4()
	local result = mList.renderTrackingCategories{item_style4 = d.arbitraryStyle}
	self:assertEquals(d.trackingCategory, result)
end

function suite:testTrackingCategoriesItemValue1()
	local result = mList.renderTrackingCategories{item_value1 = d.arbitraryValue}
	self:assertEquals(d.trackingCategory, result)
end

--------------------------------------------------------------------------------
-- Test renderList
--------------------------------------------------------------------------------

function suite.makeDataWithOneItem(args)
	local data = {
		classes = {},
		items = {},
		templatestyles = '',
	}
	data.items[1] = {content = d.item1}
	for k, v in pairs(args or {}) do
		data[k] = v
	end
	return data
end

function suite.cleanPattern(s)
	-- Cleans a pattern so that the magic characters ()%.[]*+-?^$ are interpreted literally.
	s = s:gsub('([%(%)%%%.%[%]%*%+%-%?%^%$])', '%%%1')
	return s
end

function suite.makePattern(tag, attr, s1, s2)
	-- For making a pattern to use with assertStringContains inside a specific attribute and HTML tag.
	s1 = suite.cleanPattern(s1)
	if s2 then
		s2 = suite.cleanPattern(s2)
	end
	local ssep = ''
	if s2 then
		ssep = '%s*:%s*'
	end
	s2 = s2 or ''
	return string.format(
		'<%s[^>]-%s="[^">]-%s%s%s[^">]-"[^>]->',
		tag,
		attr,
		s1,
		ssep,
		s2
	)
end

function suite:testRenderNoItems()
	self:assertEquals('', mList.renderList{})
	self:assertEquals('', mList.renderList{items = {}})
end

function suite:testRenderOneItem()
	local data = self.makeDataWithOneItem()
	self:assertStringContains('^<div>%s*<ul>%s*<li>%s*' .. self.cleanPattern(d.item1) .. '%s*</li>%s*</ul>%s*</div>$', mList.renderList(data))
end

function suite:testRenderTwoItems()
	local data = self.makeDataWithOneItem()
	data.items[2] = {content = d.item2}
	self:assertStringContains('^<div>%s*<ul>%s*<li>%s*' .. self.cleanPattern(d.item1) .. '%s*</li>%s*<li>%s*' .. self.cleanPattern(d.item2) .. '%s*</li>%s*</ul>%s*</div>$', mList.renderList(data))
end

function suite:testRenderOneClass()
	local data = self.makeDataWithOneItem()
	data.classes[1] = d.arbitraryClass
	self:assertStringContains('<div class="' .. d.arbitraryClass .. '">', mList.renderList(data), true)
end

function suite:testRenderTwoClasses()
	local data = self.makeDataWithOneItem()
	data.classes[1] = d.arbitraryClass
	data.classes[2] = d.arbitraryClass2
	local pattern = self.makePattern('div', 'class', d.arbitraryClass .. ' ' .. d.arbitraryClass2)
	self:assertStringContains(pattern, mList.renderList(data), false)
end

function suite:testRenderMarginLeft()
	local data = self.makeDataWithOneItem{marginLeft = '5px'}
	local pattern = self.makePattern('div', 'style', 'margin-left', '5px')
	self:assertStringContains(pattern, mList.renderList(data), false)
end

function suite:testRenderStyle()
	local data = self.makeDataWithOneItem{style = 'foo:bar'}
	local pattern = self.makePattern('div', 'style', 'foo:bar')
	self:assertStringContains(pattern, mList.renderList(data), false)
end

function suite:testRenderListTag()
	local data = self.makeDataWithOneItem{listTag = 'ol'}
	self:assertEquals('<div><ol><li>' .. d.item1 .. '</li></ol></div>', mList.renderList(data))
end

function suite:testRenderStart()
	local data = self.makeDataWithOneItem{start = '7'}
	local pattern = self.makePattern('ul', 'start', '7')
	self:assertStringContains(pattern, mList.renderList(data), false)
end

function suite:testRenderStartNumber()
	local data = self.makeDataWithOneItem{start = 7}
	local pattern = self.makePattern('ul', 'start', '7')
	self:assertStringContains(pattern, mList.renderList(data), false)
end

function suite:testRenderType()
	local data = self.makeDataWithOneItem{type = 'i'}
	local pattern = self.makePattern('ul', 'type', 'i')
	self:assertStringContains(pattern, mList.renderList(data), false)
end

function suite:testRenderCounterReset()
	local data = self.makeDataWithOneItem{counterReset = 'item 3'}
	local pattern = self.makePattern('ul', 'style', 'counter-reset', 'item 3')
	self:assertStringContains(pattern, mList.renderList(data), false)
end

function suite:testRenderListStyleType()
	local data = self.makeDataWithOneItem{listStyleType = 'roman'}
	local pattern = self.makePattern('ul', 'style', 'list-style-type', 'roman')
	self:assertStringContains(pattern, mList.renderList(data), false)
end

function suite:testRenderListStyle()
	local data = self.makeDataWithOneItem{listStyle = 'bar:baz'}
	local pattern = self.makePattern('ul', 'style', 'bar:baz')
	self:assertStringContains(pattern, mList.renderList(data), false)
end

function suite:testRenderItemStyle()
	local data = self.makeDataWithOneItem{itemStyle = 'qux:foo'}
	local pattern = self.makePattern('li', 'style', 'qux:foo')
	self:assertStringContains(pattern, mList.renderList(data), false)
end

function suite:testRenderItemStyleTwoItems()
	local data = self.makeDataWithOneItem{itemStyle = 'bar:foo'}
	data.items[2] = {content = d.item2}
	local tagPattern = self.makePattern('li', 'style', 'bar:foo')
	local pattern = tagPattern .. d.item1 .. '</li>' .. tagPattern .. d.item2
	self:assertStringContains(pattern, mList.renderList(data), false)
end

function suite:testRenderItem1Style()
	local data = self.makeDataWithOneItem()
	data.items[1].style = 'baz:foo'
	local pattern = self.makePattern('li', 'style', 'baz:foo')
	self:assertStringContains(pattern, mList.renderList(data), false)
end

function suite:testRenderItem1Value()
	local data = self.makeDataWithOneItem()
	data.items[1].value = d.arbitraryValue
	local pattern = self.makePattern('li', 'value', d.arbitraryValue)
	self:assertStringContains(pattern, mList.renderList(data), false)
end

--------------------------------------------------------------------------------
-- Whole-module tests
--------------------------------------------------------------------------------

function suite:testBulleted()
	local actual = mList[d.bulletedFunc]{d.item1}
	local pattern = '^<div>%s*<ul>%s*<li>%s*' .. self.cleanPattern(d.item1) .. '%s*</li>%s*</ul>%s*</div>$'
	self:assertStringContains(pattern, actual, false)
end

function suite:testUnbulleted()
	local actual = mList[d.unbulletedFunc]{d.item1}
	local pattern = '^' .. d.templatestyles_pattern .. self.makePattern('div', 'class', 'plainlist') .. '%s*<ul>%s*<li>%s*' ..
		self.cleanPattern(d.item1) .. '%s*</li>%s*</ul>%s*</div>$'
	self:assertStringContains(pattern, actual, false)
end

function suite:testHorizontal()
	local actual = mList[d.horizontalFunc]{d.item1}
	local pattern = '^' .. d.templatestyles_pattern .. self.makePattern('div', 'class', 'hlist') .. '%s*<ul>%s*<li>%s*' ..
		self.cleanPattern(d.item1) .. '%s*</li>%s*</ul>%s*</div>$'
	self:assertStringContains(pattern, actual, false)
end

function suite:testOrdered()
	local actual = mList[d.orderedFunc]{d.item1}
	local pattern = '^<div>%s*<ol>%s*<li>%s*' .. self.cleanPattern(d.item1) .. '%s*</li>%s*</ol>%s*</div>$'
	self:assertStringContains(pattern, actual, false)
end

function suite:testHorizontalOrdered()
	local actual = mList[d.horizontalOrderedFunc]{d.item1}
	local pattern = '^' .. d.templatestyles_pattern .. self.makePattern('div', 'class', 'hlist') .. '%s*<ol>%s*<li>%s*' ..
		self.cleanPattern(d.item1) .. '%s*</li>%s*</ol>%s*</div>$'
	self:assertStringContains(pattern, actual, false)
end

function suite:testTrimming()
	local actual = mList[d.orderedFunc]{'\n Foo \n'}
	-- Now many templates expect the arguments to be trimmed
	local pattern = '^<div>%s*<ol>%s*<li>' .. self.cleanPattern('Foo') .. '</li>%s*</ol>%s*</div>$'
	self:assertStringContains(pattern, actual, false)
end

function suite:testNested()
	local actual = mList[d.orderedFunc]{d.itemNested}
	local pattern = '^<div>%s*<ol>%s*<li>%s*' .. self.cleanPattern(d.itemNested) .. '%s*</li>%s*</ol>%s*</div>$'
	self:assertStringContains(pattern, actual, false)
end

return suite
Retrieved from "https://kenshi.wiki/index.php?title=Module:List/testcases&oldid=15956"