Modulo:ScribuntoUnit/man
Questa è la pagina di documentazione per Modulo:ScribuntoUnit
Questo modulo fornisce le funzionalità di unit testing per altri moduli Lua. Per testare un modulo si deve creare un'unità di test separata di solito nella voce Modulo:Nome modulo/test. Il modulo viene testato usando il modulo ScribuntoUnit che verifica che le operazioni definite nel modulo di test producano i risultati attesi.
Struttura del modulo di test[modifica wikitesto]
Per preparare un modulo di test (test suite), iniziate con il codice seguente:
local myModule = require('Module:MyModule') -- the module to be tested
local ScribuntoUnit = require('Module:ScribuntoUnit')
local suite = ScribuntoUnit:new()
Potete quindi aggiungere funzioni di test individuali all'oggetto suite object. Ogni funzine che inizia con test è trattata come un test. (Altre funzioni saranno ingorate da ScribuntoUnit, ma possono essere nei test.)
function suite:testSomeCall()
self:assertEquals('expected value', myModule.someCall(123))
self:assertEquals('other expected value', myModule.someCall(456))
end
function suite:testSomeOtherCall()
self:assertEquals('expected value', myModule.someOtherCall(123))
self:assertEquals('other expected value', myModule.someOtherCall(456))
end
I test che scrivete dovrebbero fare asserzioni che ScribuntoUnit controllerà verificare che siano vere. Per esempio, assertEquals controlla che entrambi gli argomenti che gli vengono passati sono uguali. Se ScribuntoUnit trova un'asserzione falsa il test fallirà generando un messaggio di errore. Il messaggio di errore indica qual è l'asserzione fallita (al momento non vengono effettuati altri controlli).
Il modulo di test deve terminare ritornando l'oggetto suite.
return suite
Eseguire i test[modifica wikitesto]
I test possono essere eseguiti in due modi: attraverso la console di debug Lua e mediante chiamata da una pagina wiki usando #invoke. Se eseguite i test mediante la console di debg usate il codice require('Module:MyModule/tests').run(). Se l'eseguite da una pagina wiki usate il codice {{#invoke:MyModule/tests|run}}. Questo genererà una tabella contenente i risultati. È anche possibile visualizzare una tabella più conpatta usando il codice {{#invoke:MyModule/tests|run|displayMode=short}}.
Test[modifica wikitesto]
Messaggi di errore[modifica wikitesto]
L'ultimo parametro di tutti i metodi di test è un messaggio che viene mostrato se la validazione fallisce.
self:assertEquals('expected value', myModule.someCall(123), 'This tests whether the function x does y.')
assertTrue, assertFalse[modifica wikitesto]
self:assertTrue(actual, message)
self:assertFalse(actual, message)
Questi controllano se il risultato dell'asserzione è vero o falso. Nel caso di un un controllo di falsità notate che in Lua i valori false e nil sono falsi, mentre tutto il resto viene valutato vero. Per esempio il numero 0 o una lista vuota sono "veri" in Lua.
self:assertTrue(2 + 2 == 4)
self:assertTrue('foo')
self:assertFalse(2 + 2 == 5)
self:assertFalse(nil)
assertStringContains[modifica wikitesto]
self:assertStringContains(pattern, s, plain, message)
Questi test controllano se il pattern viene trovato nella stringa s. Se plain è vero allora il pattern viene interpretato come testo letterale, altrimenti viene interpretato come pattern funzioni di ustring.
Se il pattern non viene trovato il messaggio di errore indica il valore del pattern e della stringa s; Se la stringa s è più lunga di 70 caratteri viene visualizzata una versione troncata. Questo metodo è utile per testare specifici comportamenti di testi wiki complessi.
self:assertStringContains("foo", "foobar") -- passa
self:assertStringContains("foo", "fobar") -- fallisce
self:assertStringContains(".oo", "foobar") -- passa: corrisponde a "foo"
self:assertStringContains(".oo", "foobar", true) -- fallisce: . viene interpretato come un carattere letterale
assertNotStringContains[modifica wikitesto]
self:assertNotStringContains(pattern, s, plain, message)
Questa è l'opposto di assertStringContains. Il test fallirà se pattern viene trovato nella stringa s. Se plain è vero allora pattern viene interpretato come stringa letterale, altrimenti viene interpretato come pattern funzioni di ustring.
self:assertNotStringContains("foo", "foobar") -- fallisce
self:assertNotStringContains("foo", "fobar") -- passa
self:assertNotStringContains(".oo", "foobar") -- fallisce: corrisponde a "foo"
self:assertNotStringContains(".oo", "foobar", true) -- passa: . viene interpretato come un carattere letterale
assertEquals[modifica wikitesto]
self:assertEquals(expected, actual, message)
Questo verifica se il primo parametro è uguale al secondo parametro. Se entrambi sono numeri, vengono confrontati con la funzione assertWithinDelta con delta 1e-8 (0.00000001) essendo i floating point a precisione limitata.
self:assertEquals(4, calculator.add(2, 2))
assertWithinDelta[modifica wikitesto]
self:assertWithinDelta(expected, actual, delta, message)
Per due numeri, il test verifica se i valori hanno una precisa distanza (delta) tra loro. Questo è utile per numeri floating point, che sono quelli usati nell'installazione std di Lua (per essere precisi, usa numeri double). Per esempio, nella versione di Scribunto installata su Wikipedia inglese, l'espressione 0.3 – 0.2 == 0.1 viene valutata false. Questo per il fatto che 0.3 – 0.2 è uguale a 0.09999999999999997780… e il numero 0.1 è uguale a 0.10000000000000000555…. Il piccolo errore tra i due vuole dire che Lua non li considera uquali. Quindi, il test per l'uguaglianza tra due numeri floating point, è vero all'interno di una distanza (delta) piccola tra loro, non proprio valori uguali. Questo problema non influenza i numeri interi, che sono rappresentati usando double fino a 2^53.
self:assertWithinDelta(0.1, calculator.subtract(0.3, 0.2), 1e-10)
assertDeepEquals[modifica wikitesto]
self:assertDeepEquals(expected, actual, message)
Testa quando il primo parametro è uguale al secondo. Se i parametri sono tabelle, vengono confrontati con ricorsione, e i loro __eq metametodi sono riconosciuti.
self:assertDeepEquals(table1, table2)
assertTemplateEquals[modifica wikitesto]
self:assertTemplateEquals(expected, template, args, message)
Verifica se il primo parametro è uguale a quello di una chiamata di template. Il secondo parametro è il nome del template, il terzo è una tabella contenente gli argomenti del template.
self:assertTemplateEquals(4, 'add', {2, 2}) -- vero se {{add|2|2}} è uguale a 4
Notate che alcuni tag in notazione XML non si possono testare correttamente; vedere la nota della funzione successiva assertResultEquals.
assertResultEquals[modifica wikitesto]
self:assertResultEquals(expected, text, message)
Questo test verifica se il primo parametro è uguale all'espansione di un testo wiki. Il secondo parametro può essere un qualunque testo wiki.
self:assertResultEquals(4, '{{#invoke:Calculator|add|2|2}}')
Notate che alcuni tag speciali scritti in notazione XML, come per esempio <pre>, <nowiki>, <gallery> e <ref> non possono essere confrontati direttamente. Questi tag sono convertiti in strip marker prima di essere processati dal Lua. Poiché gli strip marker sono univoci anche se generati da input identici questi test di ugualianza falliranno. Questo discorso si applica anche alle funzioni assertTemplateEquals e assertSameResult.
assertSameResult[modifica wikitesto]
self:assertSameResult(text1, text2, message)
Questo verifica se l'espansione di una data stringa di testo wiki, è uguale all'espansione di un'altra stringa di testo wiki. Questo può essere utile per verificare che un modulo si comporti nella stessa maniera di un template che è destinato a rimpiazzare.
self:assertSameResult('{{add|2|2}}', '{{#invoke:Calculator|add|2|2}}')
Notate che alcuni tags scritti in notazione XML non possono essere testati correttamente, vedi la nota per la funzione assertResultEquals più sopra.