Editing Module:Mock title/testcases

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

local suite = ScribuntoUnit:new()

--------------------------------------------------------------------------------
-- 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 page argument is supplied, an error is raised"] = function (self)
	self:assertThrows(
		function () mMockTitle.MockTitle{} end,
		"bad named argument page 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("Example", mMockTitle.MockTitle({page = "Example"}).prefixedText)
	end
end

local simplePropertyTestData = {
	{
		property = "id",
		page = "Example",
		value = 123456,
	},
	{
		property = "isRedirect",
		page = "Main Page",
		value = true,
	},
	{
		property = "exists",
		page = "Main Page",
		value = false,
	},
	{
		property = "contentModel",
		page = "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({page = testData.page, [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({page = "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({page = "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({page = "Example", redirectTarget = {page = "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({page = "User:Example/common.js", contentModel = "wikitext"})
	local title = mMockTitle.MockTitle({page = "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{page = "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{
			page = "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{page = "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{page = "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{page = "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{page = "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 = 3,
	},
	{
		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{page = "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{page = "Non-existent page 34u8wg90bfr", fileExists = true}
	self:assertEquals(nil, title.file)
end

local fileExistsTestData = {
	{
		page = "Non-existent article tr9w78ebna0",
		expected = nil,
	},
	{
		page = "Talk:Non-existent talk page 34hdbe0pafj",
		expected = nil,
	},
	{
		page = 	"File:Non-existent file 341gh87fgg8",
		expected = true,
	},
	{
		page = "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.page,
			testData.expected and "set" or "not set"
		)
	] = function (self)
		local title = mMockTitle.MockTitle({page = testData.page, fileExists = true})
		self:assertEquals(testData.expected, title.fileExists)
	end
end

local fallbackPropertyTestData = {
	{
		property = "id",
		option = "id",
		page = "Example",
	},
	{
		property = "isRedirect",
		option = "isRedirect",
		page = "WP:ANI",
	},
	{
		property = "exists",
		option = "exists",
		page = "Non-existent title f292umz0tyi",
	},
	{
		property = "contentModel",
		option = "contentModel",
		page = "User:Example/common.js",
	},
	{
		property = "redirectTarget",
		option = "redirectTarget",
		page = "WP:ANI",
	},
	{
		property = "protectionLevels",
		option = "editProtection",
		page = "Main Page",
	},
	{
		property = "redirectTarget",
		option = "redirectTarget",
		page = "WP:ANI",
	},
	{
		property = "cascadingProtection",
		option = "cascadingEditProtection",
		page = "Main Page",
	},
	{
		property = "cascadingProtection",
		option = "cascadingProtectionSources",
		page = "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.page)[testData.property],
			mMockTitle.MockTitle{page = testData.page}[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{page = "Main Page"}:getContent()
	)
end

return suite