¿Cuál es el orden de ejecución en NUnit?

Question

He estado haciendo una investigación sobre el desarrollo impulsado por pruebas y me parece genial.

Una de las cosas que encontré fue que cuando escribe sus pruebas, hay un orden de ejecución de su configuración y métodos de prueba ([Configuración] y [Prueba]).

¿Hay otras que pueda utilizar durante las pruebas y, en caso afirmativo, cuál es el orden de ejecución de las mismas, como un desecho o algo así? Vi la configuración de la instalación de prueba, pero no muy familiarizada con esa.

Ejemplo:

Cuando funciono la prueba, lo hace la [Configuración] primero y luego ejecuta el [Test] cuando se va a la siguiente prueba se corre el [Configuración] de nuevo y luego va a la [ Prueba].

Estoy usando NUnit si eso ayuda.

Aquí está un ejemplo truncada de lo que he fijado:

using NUnit.Framework; 

    namespace TestingProject 
    { 
     [TestFixture] 
     public class CustomerService_Tests 
     { 
      public string MyAccount = string.Empty; 

      [SetUp] 
      public void Setup() 
      { 
       MyAccount = "This Account"; 
      } 

      [Test] 
      public void Validate_That_Account_Is_Not_Empty() 
      { 
       Assert.That(!string.IsNullOrEmpty(MyAccount)); 
      } 

      [Test] 
      public void Validate_That_Account_Is_Empty() 
      { 
       Assert.That(string.IsNullOrEmpty(MyAccount)); 
      } 
     } 
    } 

Así, cuando corro las pruebas, lo hace la configuración y la primera prueba, la configuración y luego la segunda prueba.

Mi pregunta es qué otros tipos puedo usar durante la prueba, como [Configuración] y [Prueba] y cuál es el orden de ejecución de estos.

Answer 1

Usando NUnit (no estoy seguro acerca de los demás) que tienen el siguiente orden de ejecuciones:

TestFixtureSetup

Configuración

prueba

TearDown

Configuración

prueba

TearDown

TestFixtureTearDown

Cada vez que ejecute sus pruebas siempre va a ejecutar en ese orden.

Si mira el siguiente código, puede ver una réplica exacta de lo que estoy hablando. Incluso puede copiar y pegar este código y debería funcionar (usando NUnit, no estoy seguro si funcionará con otros).

Si ejecuta esto en modo de depuración, y pone un punto de interrupción en cada uno de los métodos, puede ver el orden de ejecución mientras depura.

using NUnit.Framework; 

namespace Tester 
{ 
    [TestFixture] 
    public class Tester 
    { 
     public string RandomVariable = string.Empty; 

     [TestFixtureSetUp] 
     public void TestFixtureSetup() 
     { 
      //This gets executed first before anything else 
      RandomVariable = "This was set in TestFixtureSetup"; 
     } 

     [SetUp] 
     public void Setup() 
     { 
      //This gets called before every test 
      RandomVariable = "This was set in Setup"; 
     } 

     [Test] 
     public void MyTest1() 
     { 
      //This is your test... 
      RandomVariable = "This was set in Test 1"; 
     } 

     [Test] 
     public void MyTest2() 
     { 
      //This is your test... 
      RandomVariable = "This was set in Test 2"; 
     } 

     [TearDown] 
     public void TestTearDown() 
     { 
      //This gets executed after your test gets executed. 
      //Used to dispose of objects and such if needed 
      RandomVariable = "This was set in TearDown"; 
     } 

     [TestFixtureTearDown] 
     public void TestFixtureTearDown() 
     { 
      //Executes Last after all tests have run. 
      RandomVariable = "This was set in TestFixtureTearDown"; 

     } 

    } 
} 

Answer 2

Mira la documentación NUnit:

http://www.nunit.org/index.php?p=attributes&r=2.2.10

El menú por el lado derecho bajo "Atributos", describe [Configuración], [Test] y otros atributos que se pueden utilizar en el desarrollo de su pruebas.

Answer 3

Para cada clase en la que tiene las pruebas, un accesorio de prueba, puede especificar 4 métodos especiales.Los nombres de los métodos no son realmente importantes, pero debe etiquetar los métodos con uno de los siguientes cuatro atributos para identificarlos.

La convención dicta que llama a los métodos igual que los atributos, pero como dije, los atributos son el bit más importante.

Tenga en cuenta que los atributos que describo aquí son los que se encuentran en NUnit, pero atributos similares (si no son los mismos) están en uso en la mayoría de los marcos de prueba de unidades.

Los atributos son:

• TestFixtureSetUp
• TestFixtureTearDown
• SetUp
• TearDown

Los dos primero tiene que ver con la clase en su conjunto. El método etiquetado con el atributo TestFixtureSetUp se ejecuta una vez, antes de la primera prueba en la clase.

Después de todas las pruebas en la clase se ha ejecutado, el método etiquetado con el atributo TestFixtureTearDown se ejecuta, una vez.

Puede usar estos dos para preparar estructuras de datos comunes que son iguales para todas las pruebas, y no son modificadas por ninguna prueba (esto es importante).

Los dos últimos, SetUp y TearDown, se utilizan para etiquetar dos métodos que se ejecutarán antes y después de cada prueba individual.

Se llama al método etiquetado con SetUp antes de cada prueba, y se llama al método etiquetado con TearDown después de cada prueba. Puede usarlos para preparar estructuras de datos comunes, que aunque son las mismas para cada prueba, se modificarán en algunas o en todas las pruebas, por lo que es mejor preparar una nueva copia nueva para cada prueba.

Trazado de la ejecución de estos métodos como pseudo-código nos da esta orden:

execute TestFixtureSetUp, if present 
for each test do 
    execute SetUp, if present 
    execute actual test 
    execute TearDown, if present 
execute TestFixtureTearDown, if present 

El uso de estos atributos son totalmente opcionales. No necesita tener un SetUp para tener un TearDown o viceversa. Son solo puntos en los que podría querer ejecutar código.

Answer 4

Tenga en cuenta que la mejor práctica es mantener los casos de prueba de la unidad independientes entre sí. Para que puedan ser entendidos, modificados y ejecutados de forma independiente.

Algunos consideran que configurar y desmontar también es una mala práctica. Ver estos enlaces para el razonamiento:

• http://jamesnewkirk.typepad.com/posts/2007/09/why-you-should-.html
• http://www.agileprogrammer.com/dotnetguy/articles/SetupTeardown.aspx

Answer 5

En NUnit 2.5.1 El orden de ejecución ha cambiado una vez más. Estoy de acuerdo en que unittest nunca debe interferir entre sí.

Answer 6

NUnit 3.0 ha hecho algunos cambios con respecto a las pruebas de unidad atributos como se indica here:

TestFixtureSetUpAttribute y TestFixtureTearDownAttribute siguen ser apoyado como sinónimos de OneTimeSetUpAttribute y OneTimeTearDownAttribute en accesorios de prueba, pero una re desuso.

Desde SetUpAttribute y TearDownAttribute se utilizan de dos maneras diferentes , no es posible simplemente despreciar su uso en SetUpFixture. Ellos han sido desautorizados en ese contexto, que es un cambio de rotura .

Por lo tanto, el orden de ejecución es el siguiente:

• OneTimeSetUp
• Configuración
• prueba
• TearDown
• Configuración
• prueba
• TearDown
• OneTimeTearDown