Domanda

Qualcuno può suggerire qualche buon framework di suite di test automatizzato per Perl?

È stato utile?

Soluzione

Dipende davvero da cosa stai cercando di fare, ma ecco alcuni retroscena per gran parte di questo.

Innanzitutto, generalmente scriveresti i tuoi programmi di test con Test::More o Test::Simple come programma di test principale:

use Test::More tests => 2;

is 3, 3, 'basic equality should work';
ok !0, '... and zero should be false';

Internamente, Test::Builder viene chiamato per restituire i risultati del test come TAP (Prova qualsiasi protocollo).Test::Harness (un sottile involucro attorno a TAP::Harness), legge e interpreta il TAP, dicendoti se i tuoi test hanno superato o meno.Lo strumento "prove" menzionato sopra è fornito in bundle con Test::Harness, quindi diciamo che salvate quanto sopra nella directory t/ (la directory standard di testing di Perl) come "numbers.t", quindi potete eseguirlo con questo comando:

prove --verbose t/numbers.t

Oppure per eseguire tutti i test in quella directory (in modo ricorsivo, supponendo che tu voglia scendere nelle sottodirectory):

prove --verbose -r t/

(--verbose, ovviamente, è facoltativo).

Come nota a margine, non utilizzare TestUnit.Molte persone lo consigliano, ma è stato abbandonato molto tempo fa e non si integra con i moderni strumenti di test.

Altri suggerimenti

Guardare Tester CPAN, che dispongono di numerosi strumenti per i test automatizzati.La maggior parte dovrebbe essere su CPAN, quindi sarai in grado di modificarlo per soddisfare le tue esigenze.È anche molto semplice scrivere il proprio tester utilizzando TAP::Harness.

Che cosa devi fare esattamente e come stai cercando di inserirlo nel tuo processo?

Finché utilizzi test che producono output TAP (Test Anything Protocol), potresti trovare utile questo: http://sourceforge.net/projects/smolder

Hai visto bruciare?

"Smoke Test Aggregator utilizzato da sviluppatori e tester per caricare (automaticamente o manualmente) e visualizzare test di fumo/regressione utilizzando il protocollo Test Anything.I dettagli e le tendenze vengono rappresentati graficamente e le notifiche vengono fornite tramite e-mail o feed Atom."

Se ho capito bene stai cercando RUBINETTO::Cablaggio

Se stai usando ExtUtils::MakeMaker O Modulo::Costruisci, quindi puoi eseguire tutti i test automaticamente inserendo il comando "make test" o "Build test", che eseguirà qualsiasi file *.t nella sottocartella t/ del tuo progetto.

Se non stai utilizzando nessuno di questi, puoi utilizzare RUBINETTO::Cablaggio per automatizzare l'esecuzione di più script di test.

Per scrivere effettivamente i test, utilizzare Prova::Altro o uno qualsiasi dei moduli che altri hanno suggerito qui.

Dobbiamo eseguire manualmente tutti i file di test per il test

Sicuramente vorrai utilizzare prove (esegue il test) e/o Module::Build (crea il tuo codice e quindi esegue i test utilizzando lo stesso codice di test cablaggio che prove utilizza internamente).

Hai detto:

"Quello che sto cercando è un framework più automatizzato in grado di eseguire test incrementali/controlli di creazione, ecc."

Non sono ancora del tutto sicuro di cosa stai cercando.Come altri hanno già detto, vuoi guardare le cose basate su Test::Harness/TAP.La stragrande maggioranza della comunità di test Perl utilizza questo framework, quindi utilizzandolo otterrai molto più supporto (e utile codice esistente).

Puoi parlare un po' di più di cosa intendi per "test incrementali/controlli di compilazione"?

Immagino che tu voglia dividere i tuoi test in gruppi in modo da eseguire solo determinate serie di test in determinate circostanze?

Ci sono un paio di modi per farlo.Il modo più semplice sarebbe usare semplicemente il file system: dividere le directory di test in modo da avere cose come:

core/
 database.t
 infrastructure.t
style/
  percritic.t
ui/
  something.t
  something-else.t

E così via...è quindi possibile utilizzare lo strumento "prova" da riga di comando per eseguirli tutti o solo alcune directory, ecc.

prove ha molte opzioni utili che ti permettono di scegliere quali test eseguire e in quale ordine (ad es.cose come l'ordine non riuscito più recentemente).Questo, da solo, probabilmente ti porterà verso ciò di cui hai bisogno.

(A proposito, è importante avere una versione recente di Test::Simple/prove/etc.dal CPAN.Le versioni recenti hanno molte, molte più funzionalità).

Se hai una mentalità OO o hai precedenti esperienze con i framework xUnit, allora potresti dare un'occhiata a Test::Class che è un framework Perl xUnit costruito sul livello TAP/Test::Harness.Penso che sia molto meglio di PerlUnit - ma direi che è così da quando l'ho scritto :-)

Dai un'occhiata a Delicious per ulteriori informazioni su Test::Class http://delicious.com/tag/Test::Class

Se questo non è ciò che cerchi, potresti entrare un po' più nel dettaglio su quale funzionalità desideri?

Saluti,

Adriano

Personalmente, mi piace Test::Most, fondamentalmente è Test::More con alcune interessanti funzionalità aggiunte.

Il framework della suite di test scelto è Collaudare l'imbragatura, che si occupa di controllare l'esecuzione di un test, raccogliere i risultati, ecc.

Esistono vari moduli per fornire determinati tipi di test, i più comuni dei quali si trovano in Prova::Semplice E Prova::Altro (entrambi sono inclusi nella distribuzione Test-Simple).L'intero spazio dei nomi Test sul CPAN è dedicato a moduli specializzati di unit test, la maggior parte dei quali sono progettati per essere eseguiti sotto Test::Harness.

Per convenzione, i test vengono archiviati nella directory t/ di un progetto e ogni file di test utilizza l'estensione file .t ;i test vengono comunemente eseguiti tramite

 prove t/*.t

Le distribuzioni dei moduli in genere includono un target make denominato "test" che esegue la suite di test prima dell'installazione.Per impostazione predefinita, il processo di installazione CPAN richiede che i test vengano superati dopo la compilazione prima che venga installato un modulo.

Sceglierei Test::More o, in generale, tutto ciò che restituisce RUBINETTO

Per ora utilizziamo Test::More ma il problema attuale è che dobbiamo eseguire manualmente tutti i file di test per eseguire i test.Quello che sto cercando è un framework più automatizzato in grado di eseguire test/controlli di creazione incrementali, ecc.

Un wrapper attorno a Test::More sarebbe l'ideale, ma andrebbe bene anche qualcosa di migliore e più funzionale.

Sto esaminando PerlUnit per vedere se questo aiuta.

Conosci l'utilità 'prove' (da App::Prove)?Puoi dirgli di eseguire tutti i test in modo ricorsivo in una determinata directory, con o senza verbosità, ecc.

Per i test automatizzati in Perl dai un'occhiata a Collaudare l'imbragatura, che contiene il prove attrezzo.

IL prove lo strumento può essere eseguito con il seguente comando:

prove -r -Ilib t

Questo testerà in modo ricorsivo tutti i file *.t nella directory 't/', durante l'aggiunta lib al percorso di inclusione.

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top