Module:Mock title/testcases: Difference between revisions

local mMockTitle = require('Module:Mock title')
local ScribuntoUnit = require('Module:ScribuntoUnit')

local suite = ScribuntoUnit:new()

--------------------------------------------------------------------------------
-- Custom assertion methods
--------------------------------------------------------------------------------

function suite:assertTitlesAreEqual(expected, actual)
	local properties = {
		'prefixedText',
		'id',
		'exists',
		'isRedirect',
		'redirectTarget',
		'contentModel',
	}
	for _, prop in ipairs(properties) do
		self:assertEquals(
			expected[prop],
			actual[prop],
			string.format('mismatch in property "%s"', prop)
		)
	end
	
	local deepProperties = {'protectionLevels', 'cascadingProtection'}
	for _, prop in ipairs(deepProperties) do
		self:assertDeepEquals(
			expected[prop],
			actual[prop],
			string.format('mismatch in property "%s"', prop)
		)
	end
	
	self:assertEquals(
		not not expected.file,
		not not actual.file,
		string.format(
			'expected %s file property; actual %s file property',
			expected.file and 'has' or 'has no',
			actual.file and 'has' or 'has no'
		)
	)
	
	if expected.file and actual.file then
		local fileProperties = {
			'exists',
			'width',
			'height',
			'size',
			'mimeType',
			'length',
		}
		for _, prop in ipairs(fileProperties) do
			self:assertEquals(
				expected.file[prop],
				actual.file[prop],
				string.format('mismatch in property "file.%s"', prop)
			)
		end
		
		self:assertDeepEquals(
			expected.file.pages,
			actual.file.pages,
			string.format('mismatch in property "%s"', prop)
		)
	end
	
	self:assertEquals(
		expected:getContent(),
		actual:getContent(),
		'mismatch in getContent()'
	)
end

function suite:assertTitlesAreNotEqual(expected, actual)
	local success, result = pcall(self.assertTitlesAreEqual, self, expected, actual)
	if success then
		self:fail(string.format(
			'Failed to assert that the specified titles are not equal (title: %s)',
			tostring(expected)
		))
	end
end

--------------------------------------------------------------------------------
-- MockTitle tests
--------------------------------------------------------------------------------

suite['test MockTitle: when no argument table is supplied, an error is raised'] = function (self)
	self:assertThrows(
		function () mMockTitle.MockTitle() end,
		"bad argument #1 to 'MockTitle' (table expected, got nil)"
	)
end

suite['test MockTitle: when no title argument is supplied, an error is raised'] = function (self)
	self:assertThrows(
		function () mMockTitle.MockTitle{} end,
		"bad named argument title to 'MockTitle' (string or number expected, got nil)"
	)
end

local pageNames = {
	'Example',
	'fr:Example',
	'Module:Sandbox',
	'Module:Sandbox/subpage',
	'mw:Test',
	'fr:b:Example',
}

for _, pageName in ipairs(pageNames) do
	suite[
		string.format(
			'test MockTitle: when using page name "%s", the prefixedText property equals the page name',
			pageName
		)
	] = function (self)
		self:assertEquals(pageName, mMockTitle.MockTitle({title = pageName}).prefixedText)
	end
end

local simplePropertyTestData = {
	{
		property = 'id',
		title = 'Example',
		value = 123456,
	},
	{
		property = 'isRedirect',
		title = 'Main Page',
		value = true,
	},
	{
		property = 'exists',
		title = 'Main Page',
		value = false,
	},
	{
		property = 'contentModel',
		title = 'Main Page',
		value = 'foo',
	},
}

for _, testData in ipairs(simplePropertyTestData) do
	suite[string.format('test MockTitle: property %s is mocked using the %s option', testData.property, testData.property)] = function (self)
		local title = mMockTitle.MockTitle({title = testData.title, [testData.property] = testData.value})
		self:assertEquals(testData.value, title[testData.property])
	end
end

suite['test MockTitle: passing a page name to the redirectTarget option causes redirectTarget to be a MockTitle object with that page name'] = function (self)
	local title = mMockTitle.MockTitle({title = 'Example', redirectTarget = 'User:Example'})
	self:assertEquals('User:Example', title.redirectTarget.prefixedText)
end

suite['test MockTitle: passing an ID to the redirectTarget option causes redirectTarget to be a MockTitle object with that ID'] = function (self)
	local mainPageId = 15580374
	local title = mMockTitle.MockTitle({title = 'Example', redirectTarget = mainPageId})
	self:assertEquals(mainPageId, title.redirectTarget.id)
end

suite['test MockTitle: passing an options table to the redirectTarget option causes redirectTarget to be a MockTitle object with those options'] = function (self)
	local title = mMockTitle.MockTitle({title = 'Example', redirectTarget = {title = 'User:Example/common.js', contentModel = 'wikitext'}})
	self:assertEquals('User:Example/common.js', title.redirectTarget.prefixedText)
	self:assertEquals('wikitext', title.redirectTarget.contentModel)
end

suite['test MockTitle: passing a MockTitle object to the redirectTarget option causes redirectTarget to be that MockTitle object'] = function (self)
	local mockRedirectTarget = mMockTitle.MockTitle({title = 'User:Example/common.js', contentModel = 'wikitext'})
	local title = mMockTitle.MockTitle({title = 'Example', redirectTarget = mockRedirectTarget})
	self:assertEquals('User:Example/common.js', title.redirectTarget.prefixedText)
	self:assertEquals('wikitext', title.redirectTarget.contentModel)
end

local protectionLevelTestData = {
	{
		optionName = 'editProtection',
		optionValue = 'sysop',
		expectedProtectionAction = 'edit',
	},
	{
		optionName = 'moveProtection',
		optionValue = 'sysop',
		expectedProtectionAction = 'move',
	},
	{
		optionName = 'createProtection',
		optionValue = 'sysop',
		expectedProtectionAction = 'create',
	},
	{
		optionName = 'uploadProtection',
		optionValue = 'sysop',
		expectedProtectionAction = 'upload',
	},
}

for _, testData in ipairs(protectionLevelTestData) do
	suite[
		string.format(
			'test MockTitle: when setting option %s to "%s", the protectionLevels table is updated accordingly',
			testData.optionName,
			testData.optionValue
		)
	] = function (self)
		local title = mMockTitle.MockTitle{title = 'Example', [testData.optionName] = testData.optionValue}
		self:assertEquals(testData.optionValue, title.protectionLevels[testData.expectedProtectionAction][1])
	end
end

local cascadingProtectionLevelTestData = {
	{
		optionName = 'cascadingEditProtection',
		optionValue = 'sysop',
		expectedProtectionAction = 'edit',
	},
	{
		optionName = 'cascadingMoveProtection',
		optionValue = 'sysop',
		expectedProtectionAction = 'move',
	},
	{
		optionName = 'cascadingCreateProtection',
		optionValue = 'sysop',
		expectedProtectionAction = 'create',
	},
	{
		optionName = 'cascadingUploadProtection',
		optionValue = 'sysop',
		expectedProtectionAction = 'upload',
	},
}

for _, testData in ipairs(cascadingProtectionLevelTestData) do
	suite[
		string.format(
			'test MockTitle: when setting option %s to "%s", '
			.. 'and when setting the cascadingProtectionSources option, '
			.. 'the cascadingProtection table is updated accordingly',
			testData.optionName,
			testData.optionValue
		)
	] = function (self)
		local title = mMockTitle.MockTitle{
			title = 'Example',
			[testData.optionName] = testData.optionValue,
			cascadingProtectionSources = {'Example', 'Example 2'},
		}
		self:assertEquals(
			testData.optionValue,
			title.cascadingProtection.restrictions[testData.expectedProtectionAction][1]
		)
		self:assertDeepEquals(
			{'Example', 'Example 2'},
			title.cascadingProtection.sources
		)
	end
end

suite['test MockTitle: when a cascading protection argument is given, but no cascading protection sources are given, an error is raised'] = function (self)
	self:assertThrows(
		function () mMockTitle.MockTitle{title = 'Example', cascadingEditProtection = 'sysop'} end,
		'a cascading protection argument was given but the cascadingProtectionSources argument was missing or empty'
	)
end

suite['test MockTitle: when a cascading protection argument is given, but the cascading protection sources table is empty, an error is raised'] = function (self)
	self:assertThrows(
		function () mMockTitle.MockTitle{title = 'Example', cascadingEditProtection = 'sysop', cascadingProtectionSources = {}} end,
		'a cascading protection argument was given but the cascadingProtectionSources argument was missing or empty'
	)
end

suite['test MockTitle: when cascading protection sources are given, but no cascading protection argument is given, an error is raised'] = function (self)
	self:assertThrows(
		function () mMockTitle.MockTitle{title = 'Example', cascadingProtectionSources = {'Example 2', 'Example 3'}} end,
		'the cascadingProtectionSources argument was given, but no cascading protection argument was given'
	)
end

suite['test MockTitle: if the content option is provided, getContent() returns the specified string'] = function (self)
	local title = mMockTitle.MockTitle{title = 'Non-existent page 29dh12yxm', content = 'some [[wikitext]] content'}
	self:assertEquals('some [[wikitext]] content', title:getContent())
end

local filePropertyTestData = {
	{
		property = 'exists',
		optionName = 'fileExists',
		optionValue = true,
	},
	{
		property = 'width',
		optionName = 'fileWidth',
		optionValue = 123,
	},
	{
		property = 'height',
		optionName = 'fileHeight',
		optionValue = 456,
	},
	{
		property = 'pages',
		optionName = 'filePages',
		optionValue =  {{height = 800, width = 600}, {height = 800, width = 600}},
	},
	{
		property = 'size',
		optionName = 'fileSize',
		optionValue = 1024,
	},
	{
		property = 'mimeType',
		optionName = 'fileMimeType',
		optionValue = 'image/png',
	},
	{
		property = 'length',
		optionName = 'fileLength',
		optionValue = 60,
	},
}

for _, testData in ipairs(filePropertyTestData) do
	suite[string.format(
			'test MockTitle: when setting option %s to "%s", the file table is updated accordingly',
			testData.optionName,
			tostring(testData.optionValue)
	)] = function(self)
		local title = mMockTitle.MockTitle{title = 'File:Non-existent hf893bc0.png', [testData.optionName] = testData.optionValue}
		self:assertEquals(testData.optionValue, title.file[testData.property])
	end
end

suite['test MockTitle: when setting fileExists in a non-file namespace, no file table is set'] = function(self)
	local title = mMockTitle.MockTitle{title = 'Non-existent page 34u8wg90bfr', fileExists = true}
	self:assertEquals(nil, title.file)
end

local fileExistsTestData = {
	{
		title = 'Non-existent article tr9w78ebna0',
		expected = nil,
	},
	{
		title = 'Talk:Non-existent talk page 34hdbe0pafj',
		expected = nil,
	},
	{
		title = 	'File:Non-existent file 341gh87fgg8',
		expected = true,
	},
	{
		title = 'Media:Non-existent file pbfhrw3v8d',
		expected = true,
	},
}

for _, testData in ipairs(fileExistsTestData) do
	suite[
		string.format(
			'test MockTitle: when using page "%s", the fileExists property is %s',
			testData.title,
			testData.expected and 'set' or 'not set'
		)
	] = function (self)
		local title = mMockTitle.MockTitle({title = testData.title, fileExists = true})
		self:assertEquals(testData.expected, title.fileExists)
	end
end

local fallbackPropertyTestData = {
	{
		property = 'id',
		option = 'id',
		title = 'Example',
	},
	{
		property = 'isRedirect',
		option = 'isRedirect',
		title = 'WP:ANI',
	},
	{
		property = 'exists',
		option = 'exists',
		title = 'Non-existent title f292umz0tyi',
	},
	{
		property = 'contentModel',
		option = 'contentModel',
		title = 'User:Example/common.js',
	},
	{
		property = 'redirectTarget',
		option = 'redirectTarget',
		title = 'WP:ANI',
	},
	{
		property = 'protectionLevels',
		option = 'editProtection',
		title = 'Main Page',
	},
	{
		property = 'redirectTarget',
		option = 'redirectTarget',
		title = 'WP:ANI',
	},
	{
		property = 'cascadingProtection',
		option = 'cascadingEditProtection',
		title = 'Main Page',
	},
	{
		property = 'cascadingProtection',
		option = 'cascadingProtectionSources',
		title = 'Main Page',
	},
}

for _, testData in ipairs(fallbackPropertyTestData) do
	suite[string.format('test MockTitle: if no %s option is specified, the real %s value is used', testData.option, testData.property)] = function (self)
		suite:assertDeepEquals(
			mw.title.new(testData.title)[testData.property],
			mMockTitle.MockTitle{title = testData.title}[testData.property]
		)
	end
end

suite['test MockTitle: if no content option is specified, getContent() returns the the real content'] = function (self)
	suite:assertEquals(
		mw.title.new('Main Page'):getContent(),
		mMockTitle.MockTitle{title = 'Main Page'}:getContent()
	)
end

suite['test MockTitle: the content property is not shared between mock objects'] = function (self)
	suite:assertNotEquals(
		mMockTitle.MockTitle{title = 'Foo', content = 'Bar'}:getContent(),
		mMockTitle.MockTitle{title = 'Foo', content = 'Baz'}:getContent()
	)
end

--------------------------------------------------------------------------------
-- patchTitleObject tests
--------------------------------------------------------------------------------

suite['test patchTitleObject: patchTitleObject returns an equivalent object to MockTitle when used on the same title'] = function (self)
	suite:assertTitlesAreEqual(
		mMockTitle.MockTitle{
			title = 'Main Page',
			isRedirect = true,
			redirectTarget = 'Wikipedia:Village stocks',
			content = '#REDIRECT: [[Wikipedia:Village stocks]]',
		},
		mMockTitle.patchTitleObject(
			mw.title.new('Main Page'),
			{
				isRedirect = true,
				redirectTarget = 'Wikipedia:Village stocks',
				content = '#REDIRECT: [[Wikipedia:Village stocks]]',
			}
		)
	)
end

suite['test patchTitleObject: title arguments are ignored'] = function (self)
	self:assertEquals(
		'User:Example',
		mMockTitle.patchTitleObject(
			mw.title.new('User:Example'),
			{title = 'Wikipedia:Sandbox'}
		).prefixedText
	)
end

--------------------------------------------------------------------------------
-- Tests for registering/deregistering mock titles
--------------------------------------------------------------------------------

local MOCK_WP_SANDBOX_ARGS = {
	title = 'Wikipedia:Sandbox',
	content = 'Some random content: zbS8mJ31l8eY',
	isRedirect = true -- Cannot be true for a real page with the above content, so we can prove it's a mock
}
local MOCK_WP_SANDBOX = mMockTitle.MockTitle(MOCK_WP_SANDBOX_ARGS)

local MOCK_MAIN_PAGE_ARGS = {
	title = 'Main Page',
	content = 'Mock main page content: 38fgbhqwu8adb',
}
local MOCK_MAIN_PAGE = mMockTitle.MockTitle(MOCK_MAIN_PAGE_ARGS)

function suite:tearDownRegistrationTests()
	mMockTitle.clearAllMockTitles()
end

suite['test registerMockTitle: real titles are used during patching when no mocks are registered'] = function (self)
	-- Setup
	local realTitle = mw.title.new('Wikipedia:Sandbox')

	-- Test
	mMockTitle.patchTitleConstructors(function ()
		self:assertTitlesAreEqual(
			mw.title.new(MOCK_WP_SANDBOX_ARGS.title),
			realTitle
		)
	end)
	
	-- Teardown
	self:tearDownRegistrationTests()
end

local registerMockTitleTestData = {
	{argType = 'option table', arg = MOCK_WP_SANDBOX_ARGS},
	{argType = 'mock title', arg = MOCK_WP_SANDBOX},
}

for _, testData in ipairs(registerMockTitleTestData) do
	suite[string.format(
		'test registerMockTitle: mocks are registered when specified using %s',
		testData.argType
	)] = function (self)
		-- Setup
		mMockTitle.registerMockTitle(testData.arg)

		-- Test
		mMockTitle.patchTitleConstructors(function ()
			self:assertTitlesAreEqual(
				mw.title.new(MOCK_WP_SANDBOX_ARGS.title),
				MOCK_WP_SANDBOX
			)
		end)
		
		-- Teardown
		self:tearDownRegistrationTests()
	end
end

for _, testData in ipairs(registerMockTitleTestData) do
	suite[string.format(
		'test registerMockCurrentTitle: mocks are registered when specified using %s',
		testData.argType
	)] = function (self)
		-- Setup
		mMockTitle.registerMockCurrentTitle(testData.arg)

		-- Test
		mMockTitle.patchTitleConstructors(function ()
			self:assertTitlesAreEqual(
				mw.title.getCurrentTitle(),
				MOCK_WP_SANDBOX
			)
		end)
		
		-- Teardown
		self:tearDownRegistrationTests()
	end
end

function suite:setUpDeregistrationTests()
	mMockTitle.registerMockTitles(MOCK_WP_SANDBOX_ARGS,	MOCK_MAIN_PAGE_ARGS)
	mMockTitle.registerMockCurrentTitle(MOCK_WP_SANDBOX_ARGS)
end

suite['test deregisterMockTitle: previously registered titles are not deregistered if a deregistration function is not called'] = function (self)
	-- Setup
	self:setUpDeregistrationTests()

	-- Test
	mMockTitle.patchTitleConstructors(function ()
		self:assertTitlesAreEqual(
			mw.title.new(MOCK_WP_SANDBOX_ARGS.title),
			MOCK_WP_SANDBOX
		)
	end)

	-- Teardown
	self:tearDownRegistrationTests()
end

local deregisterMockTitleTestData = {
	{argType = 'title', arg = MOCK_WP_SANDBOX_ARGS.title},
	{argType = 'args table', arg = MOCK_WP_SANDBOX_ARGS},
	{argType = 'ID', arg = MOCK_WP_SANDBOX.id},
	{argType = 'title object', arg = mw.title.new(MOCK_WP_SANDBOX_ARGS.title)},
	{argType = 'mock title object', arg = MOCK_WP_SANDBOX},
}

for _, testData in ipairs(deregisterMockTitleTestData) do
	suite[
		string.format(
			'test deregisterMockTitle: previously registered titles are deregistered when specified by %s',
			testData.argType
		)
	] = function (self)
		-- Setup
		self:setUpDeregistrationTests()
		local realTitle = mw.title.new(MOCK_WP_SANDBOX_ARGS.title)
		mMockTitle.deregisterMockTitle(testData.arg)

		-- Test
		mMockTitle.patchTitleConstructors(function ()
			self:assertTitlesAreEqual(
				mw.title.new(MOCK_WP_SANDBOX_ARGS.title),
				realTitle
			)
		end)

		-- Teardown
		self:tearDownRegistrationTests()
	end
end

suite['test deregisterMockCurrentTitle: the previously registered current title is not deregistered if a deregistration function is not called'] = function (self)
	-- Setup
	self:setUpDeregistrationTests()

	-- Test
	mMockTitle.patchTitleConstructors(function ()
		self:assertTitlesAreEqual(mw.title.getCurrentTitle(), MOCK_WP_SANDBOX)
	end)

	-- Teardown
	self:tearDownRegistrationTests()
end

suite['test deregisterMockCurrentTitle: the previously registered current title is deregistered if deregisterMockCurrentTitle is called'] = function (self)
	-- Setup
	self:setUpDeregistrationTests()
	local realTitle = mw.title.getCurrentTitle()
	mMockTitle.deregisterMockCurrentTitle()

	-- Test
	mMockTitle.patchTitleConstructors(function ()
		self:assertTitlesAreEqual(mw.title.getCurrentTitle(), realTitle)
	end)

	-- Teardown
	self:tearDownRegistrationTests()
end

local registerMockTitlesTestData = {
	{argType = 'option table', args = {MOCK_WP_SANDBOX_ARGS, MOCK_MAIN_PAGE_ARGS}},
	{argType = 'mock title', args = {MOCK_WP_SANDBOX, MOCK_MAIN_PAGE}},
}

for _, testData in ipairs(registerMockTitlesTestData) do
	suite[string.format(
		'test registerMockTitles: mocks are registered when specified using %s',
		testData.argType
	)] = function (self)
		-- Setup
		mMockTitle.registerMockTitles(unpack(testData.args))

		-- Test
		mMockTitle.patchTitleConstructors(function ()
			self:assertTitlesAreEqual(
				mw.title.new(MOCK_WP_SANDBOX_ARGS.title),
				MOCK_WP_SANDBOX
			)
			self:assertTitlesAreEqual(
				mw.title.new(MOCK_MAIN_PAGE_ARGS.title),
				MOCK_MAIN_PAGE
			)
		end)
		
		-- Teardown
		self:tearDownRegistrationTests()
	end
end

local deregisterMockTitlesTestData = {
	{
		argType = 'title',
		args = {MOCK_WP_SANDBOX_ARGS.title, MOCK_MAIN_PAGE_ARGS.title},
	},
	{argType = 'args table', args = {MOCK_WP_SANDBOX_ARGS, MOCK_MAIN_PAGE_ARGS}},
	{argType = 'ID', args = {MOCK_WP_SANDBOX.id, MOCK_MAIN_PAGE.id}},
	{
		argType = 'title object',
		args = {
			mw.title.new(MOCK_WP_SANDBOX_ARGS.title),
			mw.title.new(MOCK_MAIN_PAGE_ARGS.title),
		},
	},
	{argType = 'mock title object', args = {MOCK_WP_SANDBOX, MOCK_MAIN_PAGE}},
}

for _, testData in ipairs(deregisterMockTitlesTestData) do
	suite[
		string.format(
			'test deregisterMockTitle: previously registered titles are deregistered when specified by %s',
			testData.argType
		)
	] = function (self)
		-- Setup
		self:setUpDeregistrationTests()
		local realSandboxTitle = mw.title.new(MOCK_WP_SANDBOX_ARGS.title)
		local realMainPageTitle = mw.title.new(MOCK_MAIN_PAGE_ARGS.title)
		mMockTitle.deregisterMockTitles(unpack(testData.args))

		-- Test
		mMockTitle.patchTitleConstructors(function ()
			self:assertTitlesAreEqual(
				mw.title.new(MOCK_WP_SANDBOX_ARGS.title),
				realSandboxTitle
			)
			self:assertTitlesAreEqual(
				mw.title.new(MOCK_MAIN_PAGE_ARGS.title),
				realMainPageTitle
			)
		end)

		-- Teardown
		self:tearDownRegistrationTests()
	end
end

suite['test clearMockTitleRegistry: all mock titles are cleared'] = function (self)
	-- Setup
	self:setUpDeregistrationTests()
	local realSandboxTitle = mw.title.new(MOCK_WP_SANDBOX_ARGS.title)
	local realMainPageTitle = mw.title.new(MOCK_MAIN_PAGE_ARGS.title)
	mMockTitle.clearMockTitleRegistry()

	-- Test
	mMockTitle.patchTitleConstructors(function ()
		self:assertTitlesAreEqual(
			mw.title.new(MOCK_WP_SANDBOX_ARGS.title),
			realSandboxTitle
		)
		self:assertTitlesAreEqual(
			mw.title.new(MOCK_MAIN_PAGE_ARGS.title),
			realMainPageTitle
		)
	end)

	-- Teardown
	self:tearDownRegistrationTests()
end

suite['test clearAllMockTitles: all registered titles are deregistered when clearAllMockTitles is called'] = function (self)
	-- Setup
	self:setUpDeregistrationTests()
	local realSandboxTitle = mw.title.new(MOCK_WP_SANDBOX_ARGS.title)
	local realMainPageTitle = mw.title.new(MOCK_MAIN_PAGE_ARGS.title)
	local realCurrentTitle = mw.title.getCurrentTitle()
	mMockTitle.clearAllMockTitles()

	-- Test
	mMockTitle.patchTitleConstructors(function ()
		self:assertTitlesAreEqual(
			mw.title.new(MOCK_WP_SANDBOX_ARGS.title),
			realSandboxTitle
		)
		self:assertTitlesAreEqual(
			mw.title.new(MOCK_MAIN_PAGE_ARGS.title),
			realMainPageTitle
		)
		self:assertTitlesAreEqual(mw.title.getCurrentTitle(), realCurrentTitle)
	end)

	-- Teardown
	self:tearDownRegistrationTests()
end

suite['test registered mocks do not share content with standalone mocks when title constructors are patched'] = function (self)
	mMockTitle.registerMockTitle{title = 'Wikipedia:Sandbox', content = 'Foo'}
	mMockTitle.patchTitleConstructors(function ()
		self:assertTitlesAreNotEqual(
			mw.title.new('Wikipedia:Sandbox'),
			mMockTitle.MockTitle{title = 'Wikipedia:Sandbox', content = 'Bar'}
		)
	end)
	self:tearDownRegistrationTests()
end

--------------------------------------------------------------------------------
-- Tests for patching functions
--------------------------------------------------------------------------------

local patchingFunctionTestArgs = {
	{
		patchFuncName = 'patchTitleNew',
		constructorName = 'new',
		constructorArgs = {'Wikipedia:Sandbox'},
		expectedMockTitle = MOCK_WP_SANDBOX,
		expectedRealTitle = mw.title.new('Wikipedia:Sandbox'),
	},
	{
		patchFuncName = 'patchMakeTitle',
		constructorName = 'makeTitle',
		constructorArgs = {4, 'Sandbox'},
		expectedMockTitle = MOCK_WP_SANDBOX,
		expectedRealTitle = mw.title.new('Wikipedia:Sandbox'),
	},
	{
		patchFuncName = 'patchGetCurrentTitle',
		constructorName = 'getCurrentTitle',
		constructorArgs = {},
		expectedMockTitle = MOCK_WP_SANDBOX,
		expectedRealTitle = mw.title.getCurrentTitle(),
	},
}

for _, testData in ipairs(patchingFunctionTestArgs) do
	suite[
		string.format(
			'test %s: %s is patched when the func parameter is run',
			testData.patchFuncName,
			testData.constructorName
		)
	] = function (self)
		self:setUpDeregistrationTests()
		mMockTitle[testData.patchFuncName](function ()
			self:assertTitlesAreEqual(
				mw.title[testData.constructorName](unpack(testData.constructorArgs)),
				testData.expectedMockTitle
			)
		end)
		self:tearDownRegistrationTests()
	end

	suite[
		string.format(
			'test %s: %s is not patched before the function is run',
			testData.patchFuncName,
			testData.constructorName
		)
	] = function (self)
		-- Setup
		self:setUpDeregistrationTests()
		local realSandboxTitle = mw.title.new('Wikipedia:Sandbox')
		self:assertTitlesAreEqual(
			mw.title[testData.constructorName](unpack(testData.constructorArgs)),
			testData.expectedRealTitle
		)
		self:tearDownRegistrationTests()
	end

	suite[
		string.format(
			'test %s: %s is not patched after the function is run',
			testData.patchFuncName,
			testData.constructorName
		)
	] = function (self)
		-- Setup
		self:setUpDeregistrationTests()
		local realSandboxTitle = mw.title.new('Wikipedia:Sandbox')
		mMockTitle[testData.patchFuncName](function () end)
		
		-- Test
		self:assertTitlesAreEqual(
			mw.title[testData.constructorName](unpack(testData.constructorArgs)),
			testData.expectedRealTitle
		)
		
		-- Teardown
		self:tearDownRegistrationTests()
	end
end

suite['test patchTitleConstructors: all title constructors are patched when the func parameter is run'] = function (self)
	self:setUpDeregistrationTests()
	mMockTitle.patchTitleConstructors(function ()
		self:assertTitlesAreEqual(
			mw.title.new(MOCK_WP_SANDBOX_ARGS.title),
			MOCK_WP_SANDBOX
		)
		self:assertTitlesAreEqual(
			mw.title.new(MOCK_MAIN_PAGE_ARGS.title),
			MOCK_MAIN_PAGE
		)
		self:assertTitlesAreEqual(mw.title.getCurrentTitle(), MOCK_WP_SANDBOX)
	end)
	self:tearDownRegistrationTests()
end

suite['test patchTitleConstructors: title constructors are not patched after the function is run'] = function (self)
	-- Setup
	self:setUpDeregistrationTests()
	local realSandboxTitle = mw.title.new('Wikipedia:Sandbox')
	local realCurrentTitle = mw.title.getCurrentTitle()
	mMockTitle.patchTitleConstructors(function () end)

	-- Test
	self:assertTitlesAreEqual(
		mw.title.new('Wikipedia:Sandbox'),
		realSandboxTitle
	)
	self:assertTitlesAreEqual(
		mw.title.makeTitle(4, 'Sandbox'),
		realSandboxTitle
	)
	self:assertTitlesAreEqual(mw.title.getCurrentTitle(), realCurrentTitle)

	-- Teardown
	self:tearDownRegistrationTests()
end

local patchingFuncNames = {
	'patchTitleNew',
	'patchMakeTitle',
	'patchGetCurrentTitle',
	'patchTitleConstructors',
}

for _, patchFuncName in ipairs(patchingFuncNames) do
	suite[string.format('test %s: varargs are passed as arguments to the func parameter', patchFuncName)] = function (self)
		mMockTitle[patchFuncName](
			function (a, b, c)
				self:assertEquals('foo', a)
				self:assertEquals('bar', b)
				self:assertEquals('baz', c)
			end,
			'foo',
			'bar',
			'baz'
		)
	end
	
	suite[string.format('test %s: the result of func is returned', patchFuncName)] = function (self)
		local result = mMockTitle[patchFuncName](function ()
			return 'some value'
		end)
		self:assertEquals('some value', result)
	end
end

return suite