JavaScript Unit Testing integrado con CruiseControl.NET

Question

Estoy buscando framework que proporciona pruebas unitarias para JS. Más tarde, tendré que integrarlo con CruiseControl.NET. Tengo muchos sitios web asp que usan JS y necesito automatizar las pruebas para ellos. Por ejemplo, utilicé JSUnit local (puede ser otro framework), lo cual fue bastante fácil para mí, pero no tengo idea de cómo integrarlo con CC.NET. Quizás puedas enseñarme cómo empezar?

NOTA: debe ser CC.NET, marco para la prueba de la unidad no se especifica

Answer 1

que darse cuenta de que esto es una pregunta bastante antiguo, pero he tenido intereses similares por lo que figura que iba a publicar una respuesta independientemente. Supongo que está escribiendo JavaScript de estilo OO y quiere probar esos objetos.

Una solución común recomendada por las personas es ejecutar JsTestDriver y esta es definitivamente una gran herramienta; Dicho esto, requiere que la JVM esté instalada en su máquina y en el servidor de compilación. Además de requerir la JVM, JsTestDriver aún depende de ejecutar uno o más navegadores 'Esclavos'. Personalmente, creo que no debería ser una preocupación cuando la unidad prueba objetos de JavaScript. Si el foco está en la prueba de UI, entonces usar una herramienta como WatiN y es un tipo diferente de prueba en mi opinión. El navegador debe ser simulado como si simulara cualquier otra vista usando JSMock o JsMockito (que me gusta más).

Para ese fin, he usado Windows Script Host para ejecutar mis pruebas de unidades de JavaScript durante años. Esto tiene varias ventajas:

1. No se requiere navegador (para mí eso es algo bueno).
2. CScript ya está en todas las máquinas de Windows desde XP; entonces nada que instalar
3. Se ejecuta en segundo plano y no requiere una interfaz de usuario interactiva cuando se ejecutan las pruebas.
4. Dado que se ejecuta dentro de MSTest, NUnit o xUnit, etc., la integración con CC.NET, Hudson o TeamCity es tan fácil como ejecutar las pruebas unitarias como parte de la compilación.
5. Soporte completo de depuración simplemente ejecutando la prueba unitaria dentro del depurador.

Hay un par de desventajas, por supuesto:

1. La máquina que ejecuta las pruebas de unidad tiene que tener la capacidad para desovar fuera de nuevos procesos (cscript) para ejecutar realmente las pruebas (aún no se ha un problema).
2. Más lento que la ejecución de pruebas de unidades regulares (Un poco más de 1,000/minuto en un doble núcleo anterior si se ejecuta individualmente, es decir, no se agrupan en un solo proceso de CSCript).

Usando JSTest.NET (método que he utilizado durante años, pero acaba de publicar en línea), se termina con un accesorio de prueba que puede ser similar al siguiente:

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); 
          "); 
    } 
    } 
} 

Este enfoque funciona bien para mí, y es muy simple de configurar. Básicamente, es como escribir pruebas unitarias regulares, pero con JavaScript.