Module:Reply to/testcases - Revision history

Ahecht: desired output doesn't have extra spaces

2022-03-30T18:14:50Z

desired output doesn't have extra spaces

ExE Boss: 1 revision imported from mw:Module:Reply to/testcases: Update test suite

2021-08-22T17:18:35Z

1 revision imported from mw:Module:Reply to/testcases: Update test suite

← Previous revision		Revision as of 17:18, 22 August 2021
Line 58:		Line 58:

	function suite:testNoUsernamesError()		function suite:testNoUsernamesError()
	self:assertHtmlError('No ~~usernames~~ given', replyTo{})		self:assertHtmlError('Username not given', replyTo{})
	end		end

	function suite:testInvalidUsernameError()		function suite:testInvalidUsernameError()
	self:assertHtmlError("~~'%S+'~~ is ~~not~~ ~~a valid username or user page~~", replyTo{'Examp\|le'})		self:assertHtmlError("Input contains forbidden characters", replyTo{'Examp\|le'})
	end		end

Line 92:		Line 92:
	function suite:testThreeUsernames()		function suite:testThreeUsernames()
	self:assertContentEquals(		self:assertContentEquals(
	'@[[User:Example\|Example]], [[User:Example2\|Example2]], and [[User:Example3\|Example3]]:',		'@[[User:Example\|Example]], [[User:Example2\|Example2]], and [[User:Example3\|Example3]]:',
	replyTo{'Example', 'Example2', 'Example3'}		replyTo{'Example', 'Example2', 'Example3'}
	)		)
Line 99:		Line 99:
	function suite:testFourUsernames()		function suite:testFourUsernames()
	self:assertContentEquals(		self:assertContentEquals(
	'@[[User:Example\|Example]], [[User:Example2\|Example2]], [[User:Example3\|Example3]], and [[User:Example4\|Example4]]:',		'@[[User:Example\|Example]], [[User:Example2\|Example2]], [[User:Example3\|Example3]], and [[User:Example4\|Example4]]:',
	replyTo{'Example', 'Example2', 'Example3', 'Example4'}		replyTo{'Example', 'Example2', 'Example3', 'Example4'}
	)		)
Line 131:		Line 131:
	function suite:testThreeLabels()		function suite:testThreeLabels()
	self:assertContentEquals(		self:assertContentEquals(
	'@[[User:Example\|Foo]], [[User:Example2\|Bar]], and [[User:Example3\|Baz]]:',		'@[[User:Example\|Foo]], [[User:Example2\|Bar]], and [[User:Example3\|Baz]]:',
	replyTo{[1] = 'Example', label1 = 'Foo', [2] = 'Example2', label2 = 'Bar', [3] = 'Example3', label3 = 'Baz'}		replyTo{[1] = 'Example', label1 = 'Foo', [2] = 'Example2', label2 = 'Bar', [3] = 'Example3', label3 = 'Baz'}
	)		)
Line 156:		Line 156:
	function suite:testConjunction()		function suite:testConjunction()
	self:assertContentEquals(		self:assertContentEquals(
	'@[[User:Example\|Example]], [[User:Example2\|Example2]], foo [[User:Example3\|Example3]]:',		'@[[User:Example\|Example]], [[User:Example2\|Example2]], foo [[User:Example3\|Example3]]:',
	replyTo{'Example', 'Example2', 'Example3', c = 'foo'}		replyTo{'Example', 'Example2', 'Example3', c = 'foo'}
	)		)
Line 163:		Line 163:
	function suite:testBlankConjunction()		function suite:testBlankConjunction()
	self:assertContentEquals(		self:assertContentEquals(
	'@[[User:Example\|Example]], [[User:Example2\|Example2]], [[User:Example3\|Example3]]:',		'@[[User:Example\|Example]], [[User:Example2\|Example2]], [[User:Example3\|Example3]]:',
	replyTo{'Example', 'Example2', 'Example3', c = ''}		replyTo{'Example', 'Example2', 'Example3', c = ''}
	)		)

ExE Boss: 1 revision imported from mw:Module:Reply to/testcases: Use `suite:module()` function and the `module` parameter to support running different modules

2021-08-22T17:13:02Z

1 revision imported from mw:Module:Reply to/testcases: Use `suite:module()` function and the `module` parameter to support running different modules

← Previous revision		Revision as of 17:13, 22 August 2021
Line 1:		Line 1:
	local ~~mReplyTo~~ = ~~require(~~'Module:Reply to~~/sandbox~~'~~) -- the module to be tested~~		local libName = 'Module:Reply to'
	local ScribuntoUnit = require('Module:ScribuntoUnit')		local ScribuntoUnit = require('Module:ScribuntoUnit')
	local suite = ScribuntoUnit:new()		local suite = ScribuntoUnit:new()
	local frame = mw.getCurrentFrame()		local frame = mw.getCurrentFrame()

			-- 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()
			return suite.run(frame:newChild{
			title = libName .. '/testcases',
			args = {
			module = libName .. '/sandbox',
			displayMode = 'log'
			},
			})
			end

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

	--------------------------------------------------------------------------------		--------------------------------------------------------------------------------
Line 15:		Line 31:

	local function replyTo(args)		local function replyTo(args)
	return ~~mReplyTo~~.replyto(makeFrameWithParentArgs(args))		return require(suite:module()).replyto(makeFrameWithParentArgs(args))
	end		end

Pppery at 20:51, 14 October 2018

2018-10-14T20:51:27Z

← Previous revision		Revision as of 20:51, 14 October 2018
Line 34:		Line 34:
	function suite:assertContentEquals(expected, actual)		function suite:assertContentEquals(expected, actual)
	expected = '<span class="template-ping">' .. expected .. '</span>'		expected = '<span class="template-ping">' .. expected .. '</span>'
	self:assertEquals(expected, mw.text.trim(actual))		self:assertEquals(mw.text.trim(expected), mw.text.trim(actual))
	end		end

Pppery: Trim

2018-10-14T20:50:01Z

Trim

← Previous revision		Revision as of 20:50, 14 October 2018
Line 34:		Line 34:
	function suite:assertContentEquals(expected, actual)		function suite:assertContentEquals(expected, actual)
	expected = '<span class="template-ping">' .. expected .. '</span>'		expected = '<span class="template-ping">' .. expected .. '</span>'
	self:assertEquals(expected, actual)		self:assertEquals(expected, mw.text.trim(actual))
	end		end

Mr. Stradivarius: add some tests for non-standard parameter orders

2016-11-29T07:34:20Z

add some tests for non-standard parameter orders

@@ Line 163: / Line 163: @@
 		'@[[User:Example|Example]]',
 		replyTo{'Example', p = ''}
+	)
 end

Mr. Stradivarius: update tests with new link syntax and error messages

2016-11-29T07:13:21Z

update tests with new link syntax and error messages

← Previous revision		Revision as of 07:13, 29 November 2016
Line 1:		Line 1:
	local mReplyTo = require('Module:Reply to') -- the module to be tested		local mReplyTo = require('Module:Reply to/sandbox') -- the module to be tested
	local ScribuntoUnit = require('Module:ScribuntoUnit')		local ScribuntoUnit = require('Module:ScribuntoUnit')
	local suite = ScribuntoUnit:new()		local suite = ScribuntoUnit:new()
Line 42:		Line 42:

	function suite:testNoUsernamesError()		function suite:testNoUsernamesError()
	self:assertHtmlError('~~Username~~ ~~not~~ given', replyTo{})		self:assertHtmlError('No usernames given', replyTo{})
	end		end

	function suite:testInvalidUsernameError()		function suite:testInvalidUsernameError()
	self:assertHtmlError('~~Input~~ ~~contains~~ ~~forbidden~~ ~~characters'~~, replyTo{'Examp\|le'})		self:assertHtmlError("'%S+' is not a valid username or user page", replyTo{'Examp\|le'})
	end		end

Line 62:		Line 62:
	function suite:testOneUsername()		function suite:testOneUsername()
	self:assertContentEquals(		self:assertContentEquals(
	'@[[:User:Example\|Example]]:',		'@[[User:Example\|Example]]:',
	replyTo{'Example'}		replyTo{'Example'}
	)		)
Line 69:		Line 69:
	function suite:testTwoUsernames()		function suite:testTwoUsernames()
	self:assertContentEquals(		self:assertContentEquals(
	'@[[:User:Example\|Example]] and [[:User:Example2\|Example2]]:',		'@[[User:Example\|Example]] and [[User:Example2\|Example2]]:',
	replyTo{'Example', 'Example2'}		replyTo{'Example', 'Example2'}
	)		)
Line 76:		Line 76:
	function suite:testThreeUsernames()		function suite:testThreeUsernames()
	self:assertContentEquals(		self:assertContentEquals(
	'@[[:User:Example\|Example]], [[:User:Example2\|Example2]], and [[:User:Example3\|Example3]]:',		'@[[User:Example\|Example]], [[User:Example2\|Example2]], and [[User:Example3\|Example3]]:',
	replyTo{'Example', 'Example2', 'Example3'}		replyTo{'Example', 'Example2', 'Example3'}
	)		)
Line 83:		Line 83:
	function suite:testFourUsernames()		function suite:testFourUsernames()
	self:assertContentEquals(		self:assertContentEquals(
	'@[[:User:Example\|Example]], [[:User:Example2\|Example2]], [[:User:Example3\|Example3]], and [[:User:Example4\|Example4]]:',		'@[[User:Example\|Example]], [[User:Example2\|Example2]], [[User:Example3\|Example3]], and [[User:Example4\|Example4]]:',
	replyTo{'Example', 'Example2', 'Example3', 'Example4'}		replyTo{'Example', 'Example2', 'Example3', 'Example4'}
	)		)
Line 94:		Line 94:
	function suite:testLabel()		function suite:testLabel()
	self:assertContentEquals(		self:assertContentEquals(
	'@[[:User:Example\|Foo]]:',		'@[[User:Example\|Foo]]:',
	replyTo{[1] = 'Example', label = 'Foo'}		replyTo{[1] = 'Example', label = 'Foo'}
	)		)
Line 101:		Line 101:
	function suite:testLabel1()		function suite:testLabel1()
	self:assertContentEquals(		self:assertContentEquals(
	'@[[:User:Example\|Foo]]:',		'@[[User:Example\|Foo]]:',
	replyTo{[1] = 'Example', label1 = 'Foo'}		replyTo{[1] = 'Example', label1 = 'Foo'}
	)		)
Line 108:		Line 108:
	function suite:testTwoLabels()		function suite:testTwoLabels()
	self:assertContentEquals(		self:assertContentEquals(
	'@[[:User:Example\|Foo]] and [[:User:Example2\|Bar]]:',		'@[[User:Example\|Foo]] and [[User:Example2\|Bar]]:',
	replyTo{[1] = 'Example', label1 = 'Foo', [2] = 'Example2', label2 = 'Bar'}		replyTo{[1] = 'Example', label1 = 'Foo', [2] = 'Example2', label2 = 'Bar'}
	)		)
Line 115:		Line 115:
	function suite:testThreeLabels()		function suite:testThreeLabels()
	self:assertContentEquals(		self:assertContentEquals(
	'@[[:User:Example\|Foo]], [[:User:Example2\|Bar]], and [[:User:Example3\|Baz]]:',		'@[[User:Example\|Foo]], [[User:Example2\|Bar]], and [[User:Example3\|Baz]]:',
	replyTo{[1] = 'Example', label1 = 'Foo', [2] = 'Example2', label2 = 'Bar', [3] = 'Example3', label3 = 'Baz'}		replyTo{[1] = 'Example', label1 = 'Foo', [2] = 'Example2', label2 = 'Bar', [3] = 'Example3', label3 = 'Baz'}
	)		)
Line 126:		Line 126:
	function suite:testPrefix()		function suite:testPrefix()
	self:assertContentEquals(		self:assertContentEquals(
	'foo[[:User:Example\|Example]]:',		'foo[[User:Example\|Example]]:',
	replyTo{'Example', prefix = 'foo'}		replyTo{'Example', prefix = 'foo'}
	)		)
Line 133:		Line 133:
	function suite:testBlankPrefix()		function suite:testBlankPrefix()
	self:assertContentEquals(		self:assertContentEquals(
	'[[:User:Example\|Example]]:',		'[[User:Example\|Example]]:',
	replyTo{'Example', prefix = ''}		replyTo{'Example', prefix = ''}
	)		)
Line 140:		Line 140:
	function suite:testConjunction()		function suite:testConjunction()
	self:assertContentEquals(		self:assertContentEquals(
	'@[[:User:Example\|Example]], [[:User:Example2\|Example2]], foo [[:User:Example3\|Example3]]:',		'@[[User:Example\|Example]], [[User:Example2\|Example2]], foo [[User:Example3\|Example3]]:',
	replyTo{'Example', 'Example2', 'Example3', c = 'foo'}		replyTo{'Example', 'Example2', 'Example3', c = 'foo'}
	)		)
Line 147:		Line 147:
	function suite:testBlankConjunction()		function suite:testBlankConjunction()
	self:assertContentEquals(		self:assertContentEquals(
	'@[[:User:Example\|Example]], [[:User:Example2\|Example2]], [[:User:Example3\|Example3]]:', ~~-- FIXME - too many spaces~~		'@[[User:Example\|Example]], [[User:Example2\|Example2]], [[User:Example3\|Example3]]:',
	replyTo{'Example', 'Example2', 'Example3', c = ''}		replyTo{'Example', 'Example2', 'Example3', c = ''}
	)		)
Line 154:		Line 154:
	function suite:testPunctuation()		function suite:testPunctuation()
	self:assertContentEquals(		self:assertContentEquals(
	'@[[:User:Example\|Example]]foo',		'@[[User:Example\|Example]]foo',
	replyTo{'Example', p = 'foo'}		replyTo{'Example', p = 'foo'}
	)		)
Line 161:		Line 161:
	function suite:testBlankPunctuation()		function suite:testBlankPunctuation()
	self:assertContentEquals(		self:assertContentEquals(
	'@[[:User:Example\|Example]]',		'@[[User:Example\|Example]]',
	replyTo{'Example', p = ''}		replyTo{'Example', p = ''}
	)		)

Mr. Stradivarius: add label tests

2016-11-29T02:45:20Z

add label tests

@@ Line 85: / Line 85: @@
 		'@[[:User:Example|Example]], [[:User:Example2|Example2]], [[:User:Example3|Example3]], and [[:User:Example4|Example4]]:',
 		replyTo{'Example', 'Example2', 'Example3', 'Example4'}
+	)
 end

Mr. Stradivarius: add special format tests

2016-11-29T02:41:11Z

add special format tests

@@ Line 2: / Line 2: @@
 local ScribuntoUnit = require('Module:ScribuntoUnit')
 local suite = ScribuntoUnit:new()
 local frame = mw.getCurrentFrame()
@@ Line 31: / Line 30: @@
 	pattern = '^<strong class="error">Error in %[%[Template:Reply to%]%]: ' .. pattern .. '.</strong>$'
 	self:assertStringContains(pattern, output)
 end
@@ Line 57: / Line 61: @@
 function suite:testOneUsername()
-	self:assertEquals(
+	self:assertContentEquals(
-		'<span class="template-ping">@[[:User:Example|Example]]:</span>',
+		'@[[:User:Example|Example]]:',
 		replyTo{'Example'}
+	)
@@ Line 64: / Line 68: @@
 function suite:testTwoUsernames()
-	self:assertEquals(
+	self:assertContentEquals(
-		'<span class="template-ping">@[[:User:Example|Example]] and [[:User:Example2|Example2]]:</span>',
+		'@[[:User:Example|Example]] and [[:User:Example2|Example2]]:',
 		replyTo{'Example', 'Example2'}
+	)
@@ Line 71: / Line 75: @@
 function suite:testThreeUsernames()
-	self:assertEquals(
+	self:assertContentEquals(
-		'<span class="template-ping">@[[:User:Example|Example]], [[:User:Example2|Example2]], and [[:User:Example3|Example3]]:</span>',
+		'@[[:User:Example|Example]], [[:User:Example2|Example2]], and [[:User:Example3|Example3]]:',
 		replyTo{'Example', 'Example2', 'Example3'}
+	)
@@ Line 78: / Line 82: @@
 function suite:testFourUsernames()
-	self:assertEquals(
+	self:assertContentEquals(
-		'<span class="template-ping">@[[:User:Example|Example]], [[:User:Example2|Example2]], [[:User:Example3|Example3]], and [[:User:Example4|Example4]]:</span>',
+		'@[[:User:Example|Example]], [[:User:Example2|Example2]], [[:User:Example3|Example3]], and [[:User:Example4|Example4]]:',
 		replyTo{'Example', 'Example2', 'Example3', 'Example4'}
+	)
 end

Mr. Stradivarius: expand the test cases

2016-11-29T02:25:05Z

expand the test cases

@@ Line 4: / Line 4: @@
 local frame = mw.getCurrentFrame()
 local function makeFrameWithParentArgs(args)
@@ Line 13: / Line 17: @@
 local function replyTo(args)
 	return mReplyTo.replyto(makeFrameWithParentArgs(args))
 end
@@ Line 20: / Line 38: @@
 function suite:testNoUsernamesError()
-    self:assertEquals('<strong class="error">Error in [[Template:Reply to]]: Username not given.</strong>', replyTo{})
+    self:assertHtmlError('Username not given', replyTo{})
 end

← Previous revision		Revision as of 18:14, 30 March 2022
Line 4:		Line 4:
	local frame = mw.getCurrentFrame()		local frame = mw.getCurrentFrame()

	-- Helper to run all tests using sandbox version of the library from the debug console. To run against main lib, use =p.run()		-- 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()		function suite.runSandbox()
	return suite.run(frame:newChild{		return suite.run(frame:newChild{
Line 58:		Line 58:

	function suite:testNoUsernamesError()		function suite:testNoUsernamesError()
	self:assertHtmlError('Username not given', replyTo{})		self:assertHtmlError('Username not given', replyTo{})
	end		end

	function suite:testInvalidUsernameError()		function suite:testInvalidUsernameError()
	self:assertHtmlError("Input contains forbidden characters", replyTo{'Examp\|le'})		self:assertHtmlError("Input contains forbidden characters", replyTo{'Examp\|le'})
	end		end

Line 92:		Line 92:
	function suite:testThreeUsernames()		function suite:testThreeUsernames()
	self:assertContentEquals(		self:assertContentEquals(
	'@[[User:Example\|Example]], [[User:Example2\|Example2]], and [[User:Example3\|Example3]]:',		'@[[User:Example\|Example]], [[User:Example2\|Example2]], and [[User:Example3\|Example3]]:',
	replyTo{'Example', 'Example2', 'Example3'}		replyTo{'Example', 'Example2', 'Example3'}
	)		)
Line 99:		Line 99:
	function suite:testFourUsernames()		function suite:testFourUsernames()
	self:assertContentEquals(		self:assertContentEquals(
	'@[[User:Example\|Example]], [[User:Example2\|Example2]], [[User:Example3\|Example3]], and [[User:Example4\|Example4]]:',		'@[[User:Example\|Example]], [[User:Example2\|Example2]], [[User:Example3\|Example3]], and [[User:Example4\|Example4]]:',
	replyTo{'Example', 'Example2', 'Example3', 'Example4'}		replyTo{'Example', 'Example2', 'Example3', 'Example4'}
	)		)
Line 131:		Line 131:
	function suite:testThreeLabels()		function suite:testThreeLabels()
	self:assertContentEquals(		self:assertContentEquals(
	'@[[User:Example\|Foo]], [[User:Example2\|Bar]], and [[User:Example3\|Baz]]:',		'@[[User:Example\|Foo]], [[User:Example2\|Bar]], and [[User:Example3\|Baz]]:',
	replyTo{[1] = 'Example', label1 = 'Foo', [2] = 'Example2', label2 = 'Bar', [3] = 'Example3', label3 = 'Baz'}		replyTo{[1] = 'Example', label1 = 'Foo', [2] = 'Example2', label2 = 'Bar', [3] = 'Example3', label3 = 'Baz'}
	)		)
Line 156:		Line 156:
	function suite:testConjunction()		function suite:testConjunction()
	self:assertContentEquals(		self:assertContentEquals(
	'@[[User:Example\|Example]], [[User:Example2\|Example2]], foo [[User:Example3\|Example3]]:',		'@[[User:Example\|Example]], [[User:Example2\|Example2]], foo [[User:Example3\|Example3]]:',
	replyTo{'Example', 'Example2', 'Example3', c = 'foo'}		replyTo{'Example', 'Example2', 'Example3', c = 'foo'}
	)		)
Line 163:		Line 163:
	function suite:testBlankConjunction()		function suite:testBlankConjunction()
	self:assertContentEquals(		self:assertContentEquals(
	'@[[User:Example\|Example]], [[User:Example2\|Example2]], [[User:Example3\|Example3]]:',		'@[[User:Example\|Example]], [[User:Example2\|Example2]], [[User:Example3\|Example3]]:',
	replyTo{'Example', 'Example2', 'Example3', c = ''}		replyTo{'Example', 'Example2', 'Example3', c = ''}
	)		)