C'è un modo per condividere asserzioni tra le classi di test senza ereditarietà in NUnit?

Question

In MSpec è disponibile una funzione che consente di condividere le asserzioni tra più test. Si chiamano "behaviors"

comportamenti definiscono specifiche riutilizzabili che incapsulano un particolare insieme di, avete indovinato, i comportamenti; puoi quindi includere queste specifiche in qualsiasi contesto che mostra un particolare comportamento.

Tu li definiscono come una classe con asserzioni (It campi)

public class VehicleThatHasBeenStartedBehaviors 
{ 
    protected static IVehicle vehicle; 
    It should_have_a_running_engine =() => vehicle.IsEngineRunning.ShouldBeTrue(); 
    It should_be_idling =() => vehicle.RevCount.ShouldBeBetween(0, 1000); 
} 

e includerli nella classe di test come

public class when_starting_a_car 
{ 
    Behaves_like<VehicleThatHasBeenStartedBehaviors> a_started_vehicle; 
} 

Come posso fare lo stesso con NUnit?

Answer 1

Si potrebbe voler dare un'occhiata al concetto .

Ecco un SO answer che descrive come eseguire questa operazione con C# 4.0

Answer 2

È possibile utilizzare metodi di estensione a "pacchetto" i tuoi specifici del tipo asserzioni:

public static class VehicleAssertions { 
    public static void ShouldBeStarted(this IVehicle vehicle) { 
     // TODO: change these to NUnit assertions 
     vehicle.IsEngineRunning.ShouldBeTrue(); 
     vehicle.RevCount.ShouldBeBetween(0, 1000); 
    } 
} 

usarlo su un metodo di prova:

testVehicle.ShouldBeStarted(); 

Answer 3

c'è un modo per condividere le asserzioni tra le classi di test senzaEreditarietàin NUnit?

Considerando che si desidera condividere affermazioni e si sta testando per i comportamenti sulle interfacce, si può solo creare qualcosa di semplice:

public interface IBehavior 
{ 
    void Check(); 
} 

public class VehicleThatHasBeenStartedBehaviors : IBehavior 
{ 
    protected IVehicle vehicle; 

    public VehicleThatHasBeenStartedBehaviors(IVehicle vehicle) 
    { 
     this.vehicle = vehicle; 
    } 

    public void Check() 
    { 
     Assert.That(vehicle.IsEngineRunning, Is.True); 
     Assert.That(vehicle.RevCount, Is.LessThanOrEqualTo(1000)); 
     Assert.That(vehicle.RevCount, Is.GreaterThanOrEqualTo(0)); 
    } 
} 

[TestFixture] 
public class when_starting_a_car 
{ 
    protected Car car; 

    [SetUp] 
    public void SetUp() 
    { 
     car = new Car(); 
    } 

    [Test] 
    public void behaves_like_a_started_vehicle() 
    { 
     new VehicleThatHasBeenStartedBehaviors(car).Check(); 
    } 
} 

MA, se si desidera utilizzare la sintassi specificamente MSpec, credo potrebbe essere necessario implementarlo o trovare qualche framework che lo faccia per te.

EDIT

leggere i vostri commenti sulla questione mi sono reso conto che si può mancare a riutilizzare i metodi di prova, e non semplicemente asserzioni. In questo caso, puoi scrivere un customized addin for NUnit. Potrebbe sembrare un po 'eccessivo, ma sta a te decidere.

Il mio punto di partenza sarebbe scrivendo un SuiteBuilder oggetto personalizzato:

Scopo

Un SuiteBuilder è un componente aggiuntivo utilizzato per costruire un dispositivo di prova da un tipo. NUnit utilizza un SuiteBuilder per riconoscere e creare TestFixtures.

Utilizzando il proprio generatore di suite è possibile leggere alcune classi di comportamento e comporre il proprio dispositivo.

[NUnitAddin] 
public class TestCompositionAddinProvider : IAddin 
{ 
    #region IAddin Members 

    public bool Install(IExtensionHost host) 
    { 
     IExtensionPoint builders = host.GetExtensionPoint("SuiteBuilders"); 
     if (builders == null) 
      return false; 
     builders.Install(new TestCompositionSuiteBuilder()); 
     return true; 
    } 

    #endregion 
} 
public class TestCompositionSuiteBuilder : ISuiteBuilder 
{ 
    #region ISuiteBuilder Members 

    public bool CanBuildFrom(Type type) 
    { 
        //TODO: Create validation logic 
     return true; 
    } 

    public NUnit.Core.Test BuildFrom(Type type) 
    { 
     if (CanBuildFrom(type)) 
      return new ComposedSuiteExtension(type); 
     return null; 
    } 

    #endregion 
} 

public class ComposedSuiteExtension : TestSuite 
{ 
    public ComposedSuiteExtension(Type fixtureType) 
     : base(fixtureType) 
    { 
     //TODO: Create logic to add test methods from various behaviors. 
    } 
} 

Answer 4

Un'altra soluzione semplice consiste nel creare metodi di asserzione statica in una classe Helper chiamata in ogni test applicabile. Per esempio in questo modo:

public static class VehicleAssert 
{ 
    public void AssertCorrectlyStarted(IVehicle car) 
    { 
     vehicle.IsEngineRunning.ShouldBeTrue(); 
     vehicle.RevCount.ShouldBeBetween(0, 1000); 
    } 
} 

Poi in ogni TestFixture usare in questo modo:

[TestFixture] 
public class CarTest 
{ 
    [Test] 
    public void TestCarStartsCorrectly() 
    { 
     var car = new Car(); 
     car.Start(); 
     VehicleAssert.AssertCorrectlyStarted(car); 
    } 
}