Module:Wikidata/testcases

 Documentation[voir] [modifier] [historique] [purger]

❌ 4 tests échoués.

Nom Attendu Réel
✅ testTranslateI18n
✅ testTranslatePlainText
✅ testTranslateRemplacement
✅ testIsSpecialValue
✅ testIsSpecialNoValue
✅ testIsSpecialSomeValue
✅ testGetId
✅ testGetNumericId
✅ testGetMainId
✅ testEntityIdString
✅ testEntityIdTable
✅ testGetEntityValue
✅ testGetEntityTable
✅ testSplitStrSplit
✅ testSplitStrNoSplit
✅ testSplitStrTable
✅ testIsHereTrue
✅ testIsHereFalse
✅ testIsHereMatchFunctionTrue
✅ testIsHereMatchFunctionFalse
✅ testSiteLinkBase
✅ testSiteLinkProject
✅ testSiteLinkLang
✅ testSiteLinkProjectLang
✅ testSiteLinkNil
✅ testAddNewValuesBase
✅ testAddNewValuesNewItems
✅ testAddNewValuesManxnum
✅ testAddNewValuesStopval
✅ testHasQualifierEmpty
✅ testHasQualifierAcceptedqualifsTrue
✅ testHasQualifierAcceptedqualifsFalse
✅ testHasQualifierAcceptedvalsTrue
✅ testHasQualifierAcceptedvalsFalse
✅ testHasQualifierAcceptedvalsStrTrue
✅ testHasQualifierAcceptedvalsStrFalse
✅ testHasQualifierExcludequalifiervaluesTrue
❌ testHasQualifierExcludequalifiervaluesFalse Module:Wikidata/testcases:242: Fonction wd.hasQualifier : Échec lorsque utilisation du paramètre excludequalifiervalues avec une valeur présente.

Failed to assert that true is false

✅ testSortClaimsChronogical
✅ testSortClaimsInverted
✅ testSortClaimsAge
✅ testSortClaimsAgeInverted
❌ testSortClaimsAscending Lua error -- Module:Wikidata:1227: attempt to index local 'c1' (a nil value)
❌ testSortClaimsDescending Lua error -- Module:Wikidata:1227: attempt to index local 'c1' (a nil value)
❌ testSortClaimsAlphabetical Lua error -- Module:Wikidata:1243: attempt to index local 'c1' (a nil value)


Ce module ne permet pas de vérifier le fonctionnement correct des fonctions suivantes :

  • wd.getEntityIdForCurrentPage
  • wd.isPageOfQId


La documentation de ce module est générée par le modèle {{Documentation module}}.
Elle est incluse depuis sa sous-page de documentation. Veuillez placer les catégories sur cette page-là.
Les éditeurs peuvent travailler dans le bac à sable (créer).
Voir les statistiques d'appel depuis le wikicode sur l'outil wstat et les appels depuis d'autres modules.

local wd = require('Module:Wikidata')
local ScribuntoUnit = require('Module:ScribuntoUnit')
local suite = ScribuntoUnit:new()

local Q2MaybeDeleted = "L'élément Q2 n'a pas été trouvé. S'il n'existe plus, modifiez le test pour vérifier le fonctionnement de la fonction avec un autre élément."
local Q14MaybeCreated = "L'élément Q14 a été trouvé mais ce test suppose qu'il n'existe pas. Si l'élément a été créé, modifiez le test pour vérifier le fonctionnement de la fonction avec un autre élément."

--[[
Tests de la fonction wd.translate
]]
function suite:testTranslateI18n()
	 --'somevalue' est une clé de [[Module:Wikidata/I18n]].
    self:assertEquals('inconnu', wd.translate('somevalue'),
		'Fonction wd.translate : Message \'somevalue\' incorrectement récupéré de Module:Wikidata/I18n.')
end
function suite:testTranslatePlainText()
	 --'monTexte' n'est pas une clé de [[Module:Wikidata/I18n]] et doit être retourné tel quel.
    self:assertEquals('monTexte', wd.translate('monTexte'),
		'Fonction wd.translate : Texte brut non conservé.')
end
function suite:testTranslateRemplacement()
    self:assertEquals('Texte correctement remplacé', wd.translate('Texte $1 $2', 'correctement', 'remplacé'),
		'Fonction wd.translate : Remplacements de paramètres incorectement effectués.')
end

--[[
Tests de la fonction wd.isSpecial
]]
function suite:testIsSpecialValue()
    self:assertFalse(wd.isSpecial({["snaktype"] = 'value' }),
		'Fonction wd.isSpecial : Snak de type \'value\' catégorisé comme spécial.')
end
function suite:testIsSpecialNoValue()
    self:assertTrue(wd.isSpecial({["snaktype"] = 'novalue' }),
		'Fonction wd.isSpecial : Snak de type \'novalue\' non catégorisé comme spécial.')
end
function suite:testIsSpecialSomeValue()
    self:assertTrue(wd.isSpecial({["snaktype"] = 'somevalue' }),
		'Fonction wd.isSpecial : Snak de type \'somevalue\' non catégorisé comme spécial.')
end

--[[
Test de la fonction wd.getId
]]
function suite:testGetId()
    self:assertEquals("Q12345", wd.getId( {["datatype"] = "wikibase-item", ["datavalue"] = {["type"] = "wikibase-entityid", ["value"] = { ["entity-type"] = "item", ["id"] = "Q12345", ["numeric-id"] = 12345} }, ["snaktype"] = "value" }))
end

--[[
Test de la fonction wd.getNumericId
]]
function suite:testGetNumericId()
    self:assertEquals(12345, wd.getNumericId( {["datatype"] = "wikibase-item", ["datavalue"] = {["type"] = "wikibase-entityid", ["value"] = { ["entity-type"] = "item", ["id"] = "Q12345", ["numeric-id"] = 12345} }, ["snaktype"] = "value" }))
end

--[[
Test de la fonction wd.getMainId
]]
function suite:testGetMainId()
    self:assertEquals("Q12345", wd.getMainId( {["mainsnak"]={["datatype"] = "wikibase-item", ["datavalue"] = {["type"] = "wikibase-entityid", ["value"] = { ["entity-type"] = "item", ["id"] = "Q12345", ["numeric-id"] = 12345} }, ["snaktype"] = "value" }}))
end

--[[
Tests de la fonction wd.entityId
]]
function suite:testEntityIdString()
    self:assertEquals("Q12345", wd.entityId("Q12345"),
		'Fonction wd.entityId : Échec pour une entrée de type string.')
end
function suite:testEntityIdTable()
    self:assertEquals("Q12345", wd.entityId({["id"] = "Q12345" }),
		'Fonction wd.entityId : Échec pour une entrée de type table.')
end

--[[
Tests de la fonction wd.getEntity
]]
function suite:testGetEntityValue()
	self:assertTrue(mw.wikibase.getEntity('Q2'), Q2MaybeDeleted)
    self:assertDeepEquals(mw.wikibase.getEntity('Q2'), wd.getEntity("Q2"),
		'Fonction wd.entityId : Échec de la récupération de l\'entité Q2.')
end
function suite:testGetEntityTable()
    self:assertDeepEquals({ ["claims"] = {} }, wd.getEntity({ ["claims"] = {} }),
		'Fonction wd.entityId : Échec pour une entrée de type table.')
end

--[[
Tests de la fonction wd.splitStr
]]
function suite:testSplitStrSplit()
    self:assertDeepEquals({"a","b:c;d|e{f}.g[h]i'j\"k","l"}, wd.splitStr("a,b:c;d|e{f}.g[h]i'j\"k,l"))
end
function suite:testSplitStrNoSplit()
    self:assertDeepEquals({"abc"}, wd.splitStr("abc"))
end
function suite:testSplitStrTable()
    self:assertDeepEquals({"a","b","c"}, wd.splitStr({"a","b","c"}))
end

--[[
Tests de la fonction wd.isHere
]]
function suite:testIsHereTrue()
    self:assertTrue(wd.isHere({'abc','def'}, 'abc'),
		'Fonction wd.isHere : Échec pour une recherche simple.')
    self:assertTrue(wd.isHere({'abc','def','abc'}, 'abc'),
		'Fonction wd.isHere : Échec pour une recherche d\'un élément présent plusieurs fois dans une table.')
end
function suite:testIsHereFalse()
    self:assertFalse(wd.isHere({}, 'abc'),
		'Fonction wd.isHere : Échec pour une recherche d\'un élément absent.')
    self:assertFalse(wd.isHere({'def','ghi'}, 'abc'),
		'Fonction wd.isHere : Échec pour une recherche d\'un élément absent.')
end
function suite:testIsHereMatchFunctionTrue()
	local matchfunction = function(val,j)
	    return val == j
	end
    self:assertTrue(wd.isHere({'abc','def'}, 'abc'), matchfunction,
		'Fonction wd.isHere : Échec pour une recherche avec matchfunction.')
    self:assertTrue(wd.isHere({'abc','def','abc'}, 'abc'), matchfunction,
		'Fonction wd.isHere : Échec pour une recherche avec matchfunction d\'un élément présent plusieurs fois dans une table.')
end
function suite:testIsHereMatchFunctionFalse()
	local matchfunction = function(val,j)
	    return val == j
	end
    self:assertFalse(wd.isHere({}, 'abc'), matchfunction,
		'Fonction wd.isHere : Échec pour une recherche avec matchfunction d\'un élément absent.')
    self:assertFalse(wd.isHere({'def','ghi'}, 'abc'), matchfunction,
		'Fonction wd.isHere : Échec pour une recherche avec matchfunction d\'un élément absent.')
end

--[[
Tests de la fonction wd.siteLink
]]
function suite:testSiteLinkBase()
	self:assertTrue(mw.wikibase.getEntity('Q2'), Q2MaybeDeleted)
    self:assertDeepEquals({"Terre", "wiki", "fr"}, {wd.siteLink("Q2")})
end
function suite:testSiteLinkProject()
    self:assertDeepEquals({"commons:Earth", "commons", "fr"}, {wd.siteLink("Q2","commons")})
end
function suite:testSiteLinkLang()
    self:assertDeepEquals({":de:Erde", "wiki", "de"}, {wd.siteLink("Q2", nil,"de")})
end
function suite:testSiteLinkProjectLang()
    self:assertDeepEquals({":en:q:Earth", "wikiquote", "en"}, {wd.siteLink("Q2","wikiquote","en")})
end
function suite:testSiteLinkNil()
	self:assertFalse(mw.wikibase.getEntity('Q14'), Q14MaybeCreated)
    self:assertFalse(wd.siteLink("Q14"))
end

--[[
Tests de la fonction wd.addNewValues
]]
function suite:testAddNewValuesBase()
    self:assertDeepEquals({"a", "b"}, wd.addNewValues({"a", "b"}))
end
function suite:testAddNewValuesNewItems()
    self:assertDeepEquals({"a","b","c"}, wd.addNewValues({"a", "b"}, {"c", "a"}))
end
function suite:testAddNewValuesManxnum()
    self:assertDeepEquals({"a","b","c"}, wd.addNewValues({"a", "b"}, {"c", "d"}, 3))
end

function suite:testAddNewValuesStopval()
    self:assertDeepEquals({"a","b","c"}, wd.addNewValues({"a", "b"}, {"c", "d"}, nil, "c"))
end

--[[
Tests de la fonction wd.hasQualifier
]]
local hasQualifierExample = {
	["qualifiers"] = {
		["P1"] = {
			{
				["datatype"] = "wikibase-item",
				["datavalue"] = {
					["type"] = "wikibase-entityid",
					["value"] = {
						["entity-type"] = "item",
						["id"] = "Q123",
						["numeric-id"] = 123
					}
				},
				["property"] = "P1",
				["snaktype"] = "value"
			}
		}
	}
}
local hasQualifierExample2 = {
	["qualifiers"] = {
		["P1"] = {
			{
				["datatype"] = "external-id",
				["datavalue"] = {
					["type"] = "string",
					["value"] = "bonjour",
				},
				["property"] = "P1",
				["snaktype"] = "value",
			}
		}
	}
}
function suite:testHasQualifierEmpty()
    self:assertFalse(wd.hasQualifier({}))
end
function suite:testHasQualifierAcceptedqualifsTrue()
    self:assertTrue(wd.hasQualifier({ ["qualifiers"] = { ["P123"] = {}}}, "P123"),
		'Fonction wd.hasQualifier : Échec lorsque utilisation du paramètre acceptedqualifs sur un qualificateur présent.')
end
function suite:testHasQualifierAcceptedqualifsFalse()
    self:assertFalse(wd.hasQualifier({ ["qualifiers"] = { ["P1234"] = {}}}, "P123"),
		'Fonction wd.hasQualifier : Échec lorsque utilisation du paramètre acceptedqualifs sur un qualificateur absent.')
end
function suite:testHasQualifierAcceptedvalsTrue()
    self:assertTrue(wd.hasQualifier(hasQualifierExample, "P1", {"Q123"}),
		'Fonction wd.hasQualifier : Échec lorsque utilisation du paramètre acceptedvals avec une valeur présente.')
end
function suite:testHasQualifierAcceptedvalsFalse()
    self:assertFalse(wd.hasQualifier(hasQualifierExample, "P1", {"Q12"}),
		'Fonction wd.hasQualifier : Échec lorsque utilisation du paramètre acceptedvals avec une valeur absente.')
end
function suite:testHasQualifierAcceptedvalsStrTrue()
    self:assertTrue(wd.hasQualifier(hasQualifierExample2, "P1", {"bonjour"}),
		'Fonction wd.hasQualifier : Échec lorsque utilisation du paramètre acceptedvals avec une chaîne de caractères présente.')
end
function suite:testHasQualifierAcceptedvalsStrFalse()
    self:assertFalse(wd.hasQualifier(hasQualifierExample2, "P1", {"aurevoir"}),
		'Fonction wd.hasQualifier : Échec lorsque utilisation du paramètre acceptedvals avec une chaîne de caractères absente.')
end
function suite:testHasQualifierExcludequalifiervaluesTrue()
    self:assertTrue(wd.hasQualifier(hasQualifierExample, "P1", nil, {"Q12"}),
		'Fonction wd.hasQualifier : Échec lorsque utilisation du paramètre excludequalifiervalues avec une valeur absente.')
end
function suite:testHasQualifierExcludequalifiervaluesFalse()
    self:assertFalse(wd.hasQualifier(hasQualifierExample, "P1", nil, {"Q123"}),
		'Fonction wd.hasQualifier : Échec lorsque utilisation du paramètre excludequalifiervalues avec une valeur présente.')
end


--[[
Tests de la fonction wd.sortClaims
]]
local function createDateClaim(property, value)
	return {
		["mainsnak"] = {
			["datatype"] = "time",
			["datavalue"] = {
				["type"] = "time",
				["value"] = {
					["after"] = 0,
					["before"] = 0,
					["calendarmodel"] = "http://www.wikidata.org/entity/Q1985727",
					["precision"] = 11,
					["time"] = value,
					["timezone"] = 0,
				},
			},
			["property"] = property,
			["snaktype"] = "value"
		}
	}
end
--Les élements doivent être redéfinis dans chaque test car la fonction de tri modifie l'élément
--Les tests chronologique et inverted pourraient être améliorés en prenant en compte plus de cas avec à la fois 'P571', 'P580', 'P582', 'P1319' et 'P1326', avec des timezones différentes, des calendarmodel différents, etc. (ces derniers cas ne sont pas actuellement gérés par le module).
function suite:testSortClaimsChronogical()
	local dateClaim1 = createDateClaim("P571", "+2000-01-01T00:00:00Z")
	local dateClaim2 = createDateClaim("P571", "+2001-01-01T00:00:00Z")
	local dateClaim3 = createDateClaim("P571", "+2000-10-01T00:00:00Z")
	local emptyClaim = {["mainsnak"] = {}}
    self:assertDeepEquals(
		{dateClaim1, dateClaim3, dateClaim2, emptyClaim},
		wd.sortClaims({dateClaim1, dateClaim2, dateClaim3, emptyClaim}, 'chronological'),
		"Fonction wd.hasQualifier : Tri incorrect pour sorttype='chronological'.")
end
function suite:testSortClaimsInverted()
	local dateClaim1 = createDateClaim("P571", "+2000-01-01T00:00:00Z")
	local dateClaim2 = createDateClaim("P571", "+2001-01-01T00:00:00Z")
	local dateClaim3 = createDateClaim("P571", "+2000-10-01T00:00:00Z")
	local emptyClaim = {["mainsnak"] = {}}
    self:assertDeepEquals(
		{dateClaim2, dateClaim3, dateClaim1, emptyClaim},
		wd.sortClaims({dateClaim1, dateClaim2, dateClaim3, emptyClaim}, 'inverted'),
		"Fonction wd.hasQualifier : Tri incorrect pour sorttype='inverted'.")
end
local function createPersonClaim(Qid)
	return {
		["mainsnak"] = {
			["datatype"] = "wikibase-item",
			["datavalue"] = {
				["type"] = "wikibase-entityid",
				["value"] = {
					["entity-type"] = "item",
					["id"] = Qid,
					["numeric-id"] = 12345
				}
			},
			["snaktype"] = "value"
		}
	}
end
function suite:testSortClaimsAge()
	local personClaim1 = createPersonClaim("Q762") -- Léonard de Vinci, né en 1452
	local personClaim2 = createPersonClaim("Q47365") -- Marie-Antoinette, née en 1755
	local personClaim3 = createPersonClaim("Q692") -- William Shakespeare, né en 1564
	local emptyClaim = {["mainsnak"] = {}}
    self:assertDeepEquals(
		{personClaim1, personClaim3, personClaim2, emptyClaim},
		wd.sortClaims({personClaim1, personClaim2, personClaim3, emptyClaim}, 'age'),
		"Fonction wd.hasQualifier : Tri incorrect pour sorttype='age'.")
end
function suite:testSortClaimsAgeInverted()
	local personClaim1 = createPersonClaim("Q762") -- Léonard de Vinci, né en 1452
	local personClaim2 = createPersonClaim("Q47365") -- Marie-Antoinette, née en 1755
	local personClaim3 = createPersonClaim("Q692") -- William Shakespeare, né en 1564
	local emptyClaim = {["mainsnak"] = {}}
    self:assertDeepEquals(
		{personClaim2, personClaim3, personClaim1, emptyClaim},
		wd.sortClaims({personClaim1, personClaim2, personClaim3, emptyClaim}, 'ageinverted'),
		"Fonction wd.hasQualifier : Tri incorrect pour sorttype='ageinverted'.")
end
local function createQuantityClaim(value)
	return {
		["mainsnak"] = {
			["datatype"] = "quantity",
			["datavalue"] = {
				["type"] = "quantity",
				["value"] = {
					["amount"] = value,
					["unit"] = "1",
				},
			},
			["snaktype"] = "value"
		}
	}
end
function suite:testSortClaimsAscending()
	local quantityClaim1 = createQuantityClaim("+1")
	local quantityClaim2 = createQuantityClaim("0")
	local quantityClaim3 = createQuantityClaim("-1")
	local quantityClaim4 = createQuantityClaim("1")
	local emptyClaim = {["mainsnak"] = {}}
    self:assertDeepEquals(
		{quantityClaim3, quantityClaim2, quantityClaim1, quantityClaim4, emptyClaim},
		wd.sortClaims({quantityClaim1, quantityClaim2, quantityClaim3, quantityClaim4, emptyClaim}, 'ascending'),
		"Fonction wd.hasQualifier : Tri incorrect pour sorttype='ascending'.")
end
function suite:testSortClaimsDescending()
	local quantityClaim1 = createQuantityClaim("+1")
	local quantityClaim2 = createQuantityClaim("0")
	local quantityClaim3 = createQuantityClaim("-1")
	local quantityClaim4 = createQuantityClaim("1")
	local emptyClaim = {["mainsnak"] = {}}
    self:assertDeepEquals(
		{quantityClaim3, quantityClaim2, quantityClaim1, quantityClaim4, emptyClaim},
		wd.sortClaims({quantityClaim1, quantityClaim2, quantityClaim3, quantityClaim4, emptyClaim}, 'descending'),
		"Fonction wd.hasQualifier : Tri incorrect pour sorttype='descending'.")
end
local function createStrClaim(value)
	return {
		["mainsnak"] = {
			["datatype"] = "string",
			["datavalue"] = {
				["type"] = "string",
				["value"] = value,
			},
			["property"] = "P1",
			["snaktype"] = "value"
		}
	}
end
function suite:testSortClaimsAlphabetical()
	--confirmer que c'est ce qui est attendu pour un tri alphabetical
	local strClaim1 = createStrClaim("aaa")
	local strClaim2 = createStrClaim("cac")
	local strClaim3 = createStrClaim("Baa")
	local emptyClaim = {["mainsnak"] = {}}
    self:assertDeepEquals(
		{strClaim1, strClaim3, strClaim2, emptyClaim},
		wd.sortClaims({strClaim1, strClaim2, strClaim3, emptyClaim}, 'alphabetical'),
		"Fonction wd.hasQualifier : Tri incorrect pour sorttype='alphabetical'.")
end
--[[
-language priorise certaines langues en les mettant en tête. Permet aussi de trier les qualificatifs, si utilisé en conjugaison avec showonlyqualifiers. Pour l'instant l'ordre est arbitraire, français, anglais en premier, des langues latines ensuite[1]
-l'identifiant d'une propriété numérique utilisée dans les qualificatifs (par exemple P1545)
-une fonction Lua (pour les appels depuis un module).
]]

return suite

Content Disclaimer

Informasi ini disarikan dari Wikipedia dan disajikan kembali untuk tujuan edukasi. Konten tersedia di bawah lisensi CC BY-SA 3.0. Kami tidak bertanggung jawab atas ketidakakuratan data yang bersumber dari kontribusi publik tersebut.

  1. The information displayed on this website is sourced in part or in whole from Wikipedia and has been adapted for the purpose of restating it. We strive to provide accurate and relevant information, however:
  2. There is no guarantee of absolute accuracy. Wikipedia is an open, collaborative project that can be edited by anyone, so information is subject to change.
  3. It is not intended to constitute professional advice. The content displayed is for informational and educational purposes only. For important decisions (e.g., medical, legal, or financial), please consult a professional.
  4. Content copyright. Wikipedia is licensed under the Creative Commons Attribution-ShareAlike License (CC BY-SA). This means that content may be reused with appropriate attribution and shared under a similar license.
  5. Responsible use. Any risk arising from the use of information from this website is entirely the responsibility of the user.