Test unità JavaScript integrato con CruiseControl.NET

Question

Sto cercando un framework che fornisca i test unitari per JS. Successivamente, dovrò integrarlo con CruiseControl.NET. Ho un sacco di siti Web asp usando JS e ho bisogno di automatizzare i test per loro. Ad esempio, ho usato JSUnit locale (potrebbe essere un altro framework), il che è stato abbastanza facile per me, ma non ho idea di come integrarlo con CC.NET. Forse puoi mostrarmi come iniziare?

NOTA: deve essere CC.NET, quadro di unit test non specificato

Answer 1

Mi rendo conto che questa è una domanda un po 'vecchia, ma ho avuto interessi simili così ho dato io inviare una risposta a prescindere. Suppongo che tu stia scrivendo JavaScript in stile OO e volendo testare quegli oggetti.

Una soluzione comune consigliata da persone è quella di eseguire JsTestDriver e questo è sicuramente un ottimo strumento; Detto questo, richiede che JVM sia installato sul computer e sul server di build. Oltre a richiedere la JVM, JsTestDriver dipende ancora dall'esecuzione di uno o più browser "Slave". Personalmente, credo che non dovrebbe essere una preoccupazione quando l'unità prova oggetti JavaScript. Se lo stato attivo è il test dell'interfaccia utente, quindi utilizzare uno strumento come WatiN ed è un diverso tipo di test a mio parere. Il browser dovrebbe essere messo a tacere come se si stesse prendendo in giro qualsiasi altra vista usando JSMock o JsMockito (che mi piace di più).

A tal fine, ho utilizzato Windows Script Host per eseguire i test delle unità JavaScript per anni. Questo ha diversi vantaggi:

1. Nessun browser richiesto (per me è una buona cosa).
2. CScript è già presente su ogni macchina Windows da XP; quindi niente da installare.
3. Esegue il processo in background e non richiede un'interfaccia utente interattiva durante l'esecuzione dei test.
4. Poiché eseguito all'interno di MSTest, NUnit o xUnit ecc., L'integrazione con CC.NET, Hudson o TeamCity è facile come eseguire i test di unità come parte della build.
5. Supporto per il debug completo semplicemente eseguendo il test dell'unità all'interno del debugger.

ci sono un paio di svantaggi, naturalmente:

1. macchina che esegue il test di unità deve avere la capacità di generare nuovi processi (cscript) per eseguire in realtà i test (deve ancora essere un problema).
2. È più lento eseguire test di unità regolari (A poco più di 1.000/minuto su un dual core precedente se eseguito singolarmente, vale a dire, non raggruppato insieme in un singolo processo CSCript).

Utilizzando JSTest.NET (approccio che ho usato per anni, ma appena pubblicato on-line), si finisce con un dispositivo di prova che potrebbe essere simile al seguente:

using JSTest; 
using JSTest.ScriptLibraries; 
using Xunit; 

namespace JSTest.Sample 
{ 
    public class EventDispatcherTests 
    { 
    private readonly TestScript _testScript = new TestScript(); 

    public EventDispatcherTests() 
    { 
     //Append File(s) Under Test. 
     _testScript.AppendFile(@"..\..\..\Web\Scripts\eventDispatcher.js"); 

     //Append Mock/Assertion libraries. 
     _testScript.AppendBlock(new JsHamcrestLibrary()); 
     _testScript.AppendBlock(new JsMockitoLibrary()); 

     //Append Common "Setup" Scripts. 
     _testScript.AppendBlock(@"var dispatcher = new EventDispatcher(); 
           var mockHandler = JsMockito.mockFunction(); 
           var mockPredicate = JsMockito.mockFunction(); 
           var fakeEvent = { eventType: 'CommentAdded', data: 'Sample Comment' }; 
           "); 
    } 

    [Fact] 
    public void ProcessEventInvokesAttachedHandler() 
    { 
     ... 
    } 

    [Fact] 
    public void ProcessEventGracefullyHandlesPredicateException() 
    { 
     _testScript.RunTest(@"var mockPredicateAlternate = JsMockito.mockFunction(); 

          JsMockito.when(mockPredicateAlternate)(fakeEvent).thenThrow('MyException'); 

          dispatcher.attachListener(mockHandler, mockPredicateAlternate); 
          dispatcher.processEvent(fakeEvent); 

          JsMockito.verify(mockPredicateAlternate)(fakeEvent); 
          JsMockito.verifyZeroInteractions(mockHandler); 
          "); 
    } 
    } 
} 

questo approccio funziona bene per me, ed è molto semplice da configurare. Fondamentalmente, è come scrivere regolari test unitari, ma con JavaScript.